C++ byte_copy函数代码示例

size_t fmt_httpdate(char* dest,time_t t) {
  static const char days[] = "SunMonTueWedThuFriSat";
  static const char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
  struct tm* x=gmtime(&t);
  size_t i;

  if (dest==0) return 29;
  /* "Sun, 06 Nov 1994 08:49:37 GMT" */
  byte_copy(dest,3,days+3*x->tm_wday); i=3;
  i+=fmt_str(dest+i,", ");
  i+=fmt_2digits(dest+i,x->tm_mday);
  i+=fmt_str(dest+i," ");
  byte_copy(dest+i,3,months+3*x->tm_mon); i+=3;
  i+=fmt_str(dest+i," ");
  i+=fmt_2digits(dest+i,(x->tm_year+1900)/100);
  i+=fmt_2digits(dest+i,(x->tm_year+1900)%100);
  i+=fmt_str(dest+i," ");
  i+=fmt_2digits(dest+i,x->tm_hour);
  i+=fmt_str(dest+i,":");
  i+=fmt_2digits(dest+i,x->tm_min);
  i+=fmt_str(dest+i,":");
  i+=fmt_2digits(dest+i,x->tm_sec);
  i+=fmt_str(dest+i," GMT");
  return i;
}

static inline int copyfds (char *s, int const *fds, unsigned int n, unsigned char const *bits)
{
  register unsigned int i = 0 ;
  for (; i < n ; i++)
  {
    int fd = fds[i] ;
    if (fd < 0) return (errno = EINVAL, -1) ;
    if (bitarray_peek(bits, i)) fd = - fd - 1 ;
#ifdef SKALIBS_HASANCILAUTOCLOSE
    else
    {
      fd = dup(fd) ;
      if (fd < 0)
      {
        int e = errno ;
        while (i--)
        {
          s -= sizeof(int) ;
          byte_copy((char *)fd, sizeof(int), s) ;
          if (fd >= 0) fd_close(fd) ;
        }
        errno = e ;
        return 0 ;
      }
    }
#else
#endif
    byte_copy(s, sizeof(int), (char const *)&fd) ;
    s += sizeof(int) ;
  }
  return 1 ;
}

void
check_essential (int si)
{
    if (rc == 0)
    {
        struct stat st;
        const char *name = aa_service_name (aa_service (si));
        size_t l_name = strlen (name);
        char buf[l_name + 1 + sizeof (ESSENTIAL_FILENAME)];

        byte_copy (buf, l_name, name);
        byte_copy (buf + l_name, 1 + sizeof (ESSENTIAL_FILENAME), "/" ESSENTIAL_FILENAME);

        if (stat (buf, &st) < 0)
        {
            if (errno != ENOENT)
            {
                int e = errno;
                put_warn (name, "Failed to stat " ESSENTIAL_FILENAME ": ", 0);
                add_warn (strerror (e));
                end_warn ();
            }
        }
        else
            rc = 1;
    }
}

int socket_accept6(int s,char ip[16],uint16 *port,uint32 *scope_id)
{
#ifdef LIBC_HAS_IP6
  struct sockaddr_in6 sa;
#else
  struct sockaddr_in sa;
#endif
  unsigned int dummy = sizeof sa;
  int fd;

  fd = accept(s,(struct sockaddr *) &sa,&dummy);
  if (fd == -1) return -1;

#ifdef LIBC_HAS_IP6
  if (sa.sin6_family==AF_INET) {
    struct sockaddr_in *sa4=(struct sockaddr_in*)&sa;
    byte_copy(ip,12,V4mappedprefix);
    byte_copy(ip+12,4,(char *) &sa4->sin_addr);
    uint16_unpack_big((char *) &sa4->sin_port,port);
    return fd;
  }
  byte_copy(ip,16,(char *) &sa.sin6_addr);
  uint16_unpack_big((char *) &sa.sin6_port,port);
  if (scope_id) *scope_id=sa.sin6_scope_id;

  return fd;
#else
  byte_copy(ip,12,V4mappedprefix);
  byte_copy(ip+12,4,(char *) &sa.sin_addr);
  uint16_unpack_big((char *) &sa.sin_port,port);
  if (scope_id) *scope_id=0;
  return fd;
#endif
}

int
aa_service_status_write (aa_service_status *svst, const char *dir)
{
    size_t len = strlen (dir);
    char file[len + 1 + sizeof (AA_SVST_FILENAME)];
    mode_t mask;
    int r;
    int e;

    if (!stralloc_ready_tuned (&svst->sa, AA_SVST_FIXED_SIZE, 0, 0, 1))
        return -1;

    tain_pack (svst->sa.s, &svst->stamp);
    uint32_pack (svst->sa.s + 12, (uint32_t) svst->event);
    uint32_pack (svst->sa.s + 16, (uint32_t) svst->code);
    if (svst->sa.len < AA_SVST_FIXED_SIZE)
        svst->sa.len = AA_SVST_FIXED_SIZE;

    byte_copy (file, len, dir);
    byte_copy (file + len, 1 + sizeof (AA_SVST_FILENAME), "/" AA_SVST_FILENAME);

    mask = umask (0033);
    if (!openwritenclose_suffix (file, svst->sa.s,
                svst->sa.len + ((svst->sa.len > AA_SVST_FIXED_SIZE) ? -1 : 0), ".new"))
        r = -1;
    else
        r = 0;
    e = errno;
    umask (mask);

    tain_now_g ();
    errno = e;
    return r;
}

/* if the <path> is relative and <cwd> is non-null then it is prepended
 * to the path, so it will work like shell_canonicalize, except that
 * relative paths will be resolved to absolute ones.
 * ----------------------------------------------------------------------- */
int shell_realpath(const char *path, stralloc *sa,
                   int symbolic, stralloc *cwd) {
  /* if its not absolute on the first recursion level then make it so */
  if(*path != '/' && sa->len == 0) {
    char buf[PATH_MAX + 1];

    /* check whether the name fits */
    unsigned long n;
    n = str_len(path);

    if(cwd->len + n + 1 > PATH_MAX) {
      errno = ENAMETOOLONG;
      return 0;
    }

    /* copy current dir */
    byte_copy(buf, cwd->len, cwd->s);
    buf[cwd->len] = '/';
    byte_copy(&buf[cwd->len + 1], n + 1, path);

    /* run canonicalize with the concatenated path */
    return shell_canonicalize(buf, sa, symbolic);
  }

  return shell_canonicalize(path, sa, symbolic);
}

int socket_remote6(int s,char ip[16],uint16 *port,uint32 *scope_id)
{
#ifdef LIBC_HAS_IP6
  struct sockaddr_in6 si;
#else
  struct sockaddr_in si;
#endif
  socklen_t len = sizeof si;

  if (getpeername(s,(struct sockaddr *) &si,&len) == -1) return -1;
#ifdef LIBC_HAS_IP6
  if (si.sin6_family==AF_INET) {
    struct sockaddr_in *si4=(struct sockaddr_in*)&si;
    byte_copy(ip,12,V4mappedprefix);
    byte_copy(ip+12,4,(char *) &si4->sin_addr);
    uint16_unpack_big((char *) &si4->sin_port,port);
    return 0;
  }
  byte_copy(ip,16,(char *) &si.sin6_addr);
  uint16_unpack_big((char *) &si.sin6_port,port);
  if (scope_id) *scope_id=si.sin6_scope_id;
#else
  byte_copy(ip,12,V4mappedprefix);
  byte_copy(ip+12,4,(char *) &si.sin_addr);
  uint16_unpack_big((char *) &si.sin_port,port);
  if (scope_id) *scope_id=0;
#endif
  return 0;
}

int socket_recv6(int s,char *buf,unsigned int len,char ip[16],uint16 *port,uint32 *scope_id)
{
#ifdef LIBC_HAS_IP6
  struct sockaddr_in6 sa;
#else
  struct sockaddr_in sa;
#endif
  unsigned int dummy = sizeof sa;
  int r;

  byte_zero(&sa,dummy);
  r = recvfrom(s,buf,len,0,(struct sockaddr *) &sa,&dummy);
  if (r == -1) return -1;

#ifdef LIBC_HAS_IP6
  if (noipv6) {
    struct sockaddr_in *sa4=(struct sockaddr_in *)&sa;
    byte_copy(ip,12,V4mappedprefix);
    byte_copy(ip+12,4,(char *) &sa4->sin_addr);
    uint16_unpack_big((char *) &sa4->sin_port,port);
    return r;
  }
  byte_copy(ip,16,(char *) &sa.sin6_addr);
  uint16_unpack_big((char *) &sa.sin6_port,port);
  if (scope_id) *scope_id=sa.sin6_scope_id;
#else
  byte_copy(ip,12,(char *)V4mappedprefix);
  byte_copy(ip+12,4,(char *) &sa.sin_addr);
  uint16_unpack_big((char *) &sa.sin_port,port);
  if (scope_id) *scope_id=0;
#endif

  return r;
}

int s6_svc_main (int argc, char const *const *argv, char const *optstring, char const *usage, char const *controldir)
{
  char data[DATASIZE] ;
  unsigned int datalen = 0 ;
  register int r ;
  for (;;)
  {
    register int opt = subgetopt(argc, argv, optstring) ;
    if (opt == -1) break ;
    if (opt == '?') strerr_dieusage(100, usage) ;
    if (datalen >= DATASIZE) strerr_dief1x(100, "too many commands") ;
    data[datalen++] = opt ;
  }
  argc -= subgetopt_here.ind ; argv += subgetopt_here.ind ;
  if (!argc) strerr_dieusage(100, usage) ;

  {
    unsigned int arglen = str_len(*argv) ;
    unsigned int cdirlen = str_len(controldir) ;
    char tmp[arglen + cdirlen + 10] ;
    byte_copy(tmp, arglen, *argv) ;
    tmp[arglen] = '/' ;
    byte_copy(tmp + arglen + 1, cdirlen, controldir) ;
    byte_copy(tmp + arglen + 1 + cdirlen, 9, "/control") ;
    r = s6_svc_write(tmp, data, datalen) ;
  }
  if (r < 0) strerr_diefu2sys(111, "control ", *argv) ;
  else if (!r) strerr_diefu3x(100, "control ", *argv, ": supervisor not listening") ;
  return 0 ;
}

static int doit(char *q,char qtype[2],char ip[4])
{
    int r;
    uint32 dlen;
    unsigned int qlen;

    qlen = dns_domain_length(q);
    if (qlen > 255) return 0; /* impossible */

    if (byte_diff(qtype,2,DNS_T_A) && byte_diff(qtype,2,DNS_T_ANY)) goto REFUSE;

    key[0] = '%';
    byte_copy(key + 1,4,ip);

    r = cdb_find(&c,key,5);
    if (!r) r = cdb_find(&c,key,4);
    if (!r) r = cdb_find(&c,key,3);
    if (!r) r = cdb_find(&c,key,2);
    if (r == -1) return 0;

    key[0] = '+';
    byte_zero(key + 1,2);
    if (r && (cdb_datalen(&c) == 2))
        if (cdb_read(&c,key + 1,2,cdb_datapos(&c)) == -1) return 0;

    byte_copy(key + 3,qlen,q);
    case_lowerb(key + 3,qlen + 3);

    r = cdb_find(&c,key,qlen + 3);
    if (!r) {
        byte_zero(key + 1,2);
        r = cdb_find(&c,key,qlen + 3);
    }
    if (!r) goto REFUSE;
    if (r == -1) return 0;
    dlen = cdb_datalen(&c);

    if (dlen > 512) dlen = 512;
    if (cdb_read(&c,data,dlen,cdb_datapos(&c)) == -1) return 0;

    dns_sortip(data,dlen);

    if (dlen > 12) dlen = 12;
    while (dlen >= 4) {
        dlen -= 4;
        if (!response_rstart(q,DNS_T_A,"\0\0\0\5")) return 0;
        if (!response_addbytes(data + dlen,4)) return 0;
        response_rfinish(RESPONSE_ANSWER);
    }

    return 1;


REFUSE:
    response[2] &= ~4;
    response[3] &= ~15;
    response[3] |= 5;
    return 1;
}

int dns_domain_fromdot_static(unsigned char *name,const unsigned char *buf,long long n)
{
  unsigned char label[63];
  long long labellen = 0; /* <= sizeof label */
  long long namelen = 0; /* <= sizeof name */
  unsigned char ch;

  errno = EPROTO;
  if (n < 0) return 0;
  byte_zero(name, 256);

  for (;;) {
    if (!n) break;
    ch = *buf++; --n;
    if (ch == '.') {
      if (labellen > 0) {
        if (namelen + labellen + 1 > 255) return 0;
        name[namelen++] = labellen;
        byte_copy(name + namelen,labellen,label);
        namelen += labellen;
        labellen = 0;
      }
      continue;
    }
    if (ch == '\\') {
      if (!n) break;
      ch = *buf++; --n;
      if ((ch >= '0') && (ch <= '7')) {
        ch -= '0';
        if (n && (*buf >= '0') && (*buf <= '7')) {
          ch <<= 3;
          ch += *buf - '0';
          ++buf; --n;
          if (n && (*buf >= '0') && (*buf <= '7')) {
            ch <<= 3;
            ch += *buf - '0';
            ++buf; --n;
          }
        }
      }
    }
    if (labellen >= sizeof label) return 0;
    label[labellen++] = ch;
  }

  if (labellen > 0) {
    if (namelen + labellen + 1 > 255) return 0;
    name[namelen++] = labellen;
    byte_copy(name + namelen,labellen,label);
    namelen += labellen;
    labellen = 0;
  }

  if (namelen + 1 > 255) return 0;
  name[namelen++] = 0;

  return 1;
}

int main(void) {

    unsigned char b1[32];
    unsigned char b2[32];
    long long i, j;
    const char *x = "abcdefgh";
    char y[8];

    /* byte_zero test */
    for (i = 0; i < 32; ++i) {
        for (j = 0; j < sizeof b1; ++j) b1[j] = 0;
        for (j = 0; j < sizeof b2; ++j) b2[j] = 0;
        b1[i] = 0xff; b2[i] = 0xff;
        byte_zero(b1, sizeof b1);

        if (byte_isequal(b1, 32, b2) != 0) fail("byte_zero failure");
    }

    /* byte_isequal test */
    for (i = 0; i < sizeof b1; ++i) b1[i] = 0xff;
    for (i = 0; i < sizeof b2; ++i) b2[i] = 0xff;

    if (byte_isequal(b1, 32, b2) == 0) fail("byte_isequal failure");

    for (i = 0; i < 32; ++i) {
        b1[i] = 0;
        if (byte_isequal(b1, 32, b2) != 0) fail("byte_isequal failure");
        b1[i] = 0xff;
    }

    /* byte_copy test */
    for (i = 0; i < sizeof b1; ++i) b1[i] = 0xff;
    for (i = 0; i < sizeof b2; ++i) b2[i] = 0x00;

    byte_copy(b1, 32, b2);
    if (byte_isequal(b1, 32, b2) == 0) fail("byte_copy failure");
    
    for (i = 0; i < 32; ++i) {
        b1[i] = 0;
        byte_copy(b1, 32, b2);
        if (byte_isequal(b1, 32, b2) == 0) fail("byte_copy failure");
        b1[i] = 0xff;
    }

    byte_zero(y, 8);
    if (!byte_isequal(y, 8, "\0\0\0\0\0\0\0\0")) fail("byte_zero/byte_isequal failure");

    byte_copy(y, 8, x);
    if (!byte_isequal(y, 8, x)) fail("byte_copy/byte_isequal failure");

    byte_copy(y, 7, y + 1);
    if (!byte_isequal(y, 8, "bcdefghh")) fail("byte_copy/byte_isequal failure");

    byte_zero(y, 8);
    if (!byte_isequal(y, 8, "\0\0\0\0\0\0\0\0")) fail("byte_zero/byte_isequal failure");

    return 0;
}

int socket_bind(int fd,const unsigned char *ip,const unsigned char *port)
{
  struct sockaddr_in sa;
  byte_zero(&sa,sizeof sa);
  sa.sin_family = PF_INET;
  byte_copy(&sa.sin_addr,4,ip);
  byte_copy(&sa.sin_port,2,port);
  return bind(fd,(struct sockaddr *) &sa,sizeof sa);
}

static void swap(unsigned char *x, long long len, unsigned char *y) {

    unsigned char t[33];

    byte_copy(t, len, x);
    byte_copy(x, len, y);
    byte_copy(y, len, t);

}

void random_unsort (char *s, unsigned int n, unsigned int chunksize)
{
  char tmp[chunksize] ;
  while (n--)
  {
    register unsigned int i = badrandom_int(n+1) ;
    byte_copy(tmp, chunksize, s + i * chunksize) ;
    byte_copy(s + i * chunksize, chunksize, s + n * chunksize) ;
    byte_copy(s + n * chunksize, chunksize, tmp) ;
  }
}