自学教程：C++ strbuf函数代码示例

static stragent_userdir_search (const char *tmpdir, u_int32_t uid, bool create){  DIR *dp = opendir (".");  if (!dp) {    warn ("%s: %m/n", tmpdir);    return NULL;  }  str rx (strbuf ("sfs-%d-(0|[1-9]//d{0,6})", uid));  rxx filter (rx);  u_int best = (u_int) -1;  while (dirent *dep = readdir (dp)) {    if (filter.match (dep->d_name)) {      u_int num = atoi (filter[1]);      str file (strbuf ("sfs-%d-%u", uid, num));      assert (file == dep->d_name);      if (num < best && agent_userdir_ok (file, uid))	best = num;    }  }  closedir (dp);  if (best != (u_int) -1)    return strbuf ("sfs-%d-%u", uid, best);  else if (!create)    return NULL;  for (u_int n = 0; n < 1999999; n++) {    str path (strbuf ("sfs-%d-%u", uid, n));    if (!mkdir (path, 0700))      return path;    else if (errno != EEXIST)      return NULL;    /* utimes because we want to avoid having cron jobs delete the old     * directory we are now using.  There is a tiny race condition in     * that our utimes and agent_userdir_ok could both execute     * between, say, lstat and exec calls in find. */    else if (!utimes (path, NULL) && agent_userdir_ok (path, uid))      return path;  }  return NULL;}

void Log::endlog(Tlsdata &tlsd, Level clvl){    wchar_t buf[128];    time_t now_sec;    usec_t now_usec;    wstring &strbuf(tlsd.strbuf);    lck.Enter();    if (!ffd.open())        ffd.open(ffd.file());    ffd.lock();    now_usec = microtime();    now_sec = (unsigned)(now_usec / 1000000);    if (now_sec != last_sec)    {        wchar_t *p;        struct tm *tm;        tm = localtime(&now_sec);        wcsftime(buf, sizeof (buf) / sizeof (wchar_t), fmt, tm);        if (last_fmt != NULL)            free(last_fmt);        last_fmt = wcsdup(buf);        last_sec = now_sec;        p = wcsstr(last_fmt, USubst);        upos = p ? (int)(p - last_fmt) : -1;    }    strbuf = last_fmt;    if (upos != -1)    {        wsprintf(buf, L"%06u", (unsigned)(now_usec % 1000000));        strbuf.replace(upos, 2, buf);    }    if (!strbuf.empty())        strbuf += ' ';    strbuf += LevelStr[clvl];    if (clvl == Err)        strbuf += ' ';    strbuf += ' ';    if (!tlsd.prefix.empty())    {        strbuf += tlsd.prefix;        strbuf += ' ';    }    strbuf.append(tlsd.strm.str(), (unsigned)tlsd.strm.size());    if (strbuf.at(strbuf.length() - 1) != '/n') {        strbuf += '/r';        strbuf += '/n';    }    ffd.write(strbuf.c_str(), (unsigned)strbuf.size());    ffd.unlock();    lck.Leave();    tlsd.clvl = None;    tlsd.space = false;    tlsd.strm.reset();}

longvnode_impl::doRPC (ref<location> l, const rpc_program &prog, int procno, 		   ptr<void> in, void *out, aclnt_cb cb,		   cbtmo_t cb_tmo /* = NULL */, bool stream /* = false */){  //check to see if this is alive  ptr<location> loc = locations->lookup (l->id ());  if (loc && !loc->alive()) {    warn << my_ID () << ": doRPC (" << prog.name << "." << procno          << ") on dead node " << l->address () << "/n";    delaycb (0, wrap (&err_cb, cb));    return -1;  }  ptr<dorpc_arg> arg = marshal_doRPC (l, prog, procno, in);  if (!arg) {    cb (RPC_CANTSEND);    return 0;  } else {    // This is the real call; cf transport tracking in stp_manager.    track_call (prog, procno, arg->args.size ());    ref<dorpc_res> res = New refcounted<dorpc_res> (DORPC_OK);    xdrproc_t outproc = prog.tbl[procno].xdr_res;    u_int32_t xid = random_getword ();    // Stolen (mostly) from aclnt::init_call    if (aclnttrace >= 2) {      str name;      const rpcgen_table *rtp;      rtp = &prog.tbl[procno];      assert (rtp);      name = strbuf ("%s:%s fake_xid=%x", prog.name, rtp->name, xid)	 	 << " on " << l->address () << ":" << l->vnode ();            warn << "ACLNT_TRACE:" << tracetime () << " call " << name << "/n";      if (aclnttrace >= 5 && rtp->print_arg)	rtp->print_arg (in, NULL, aclnttrace - 4, "ARGS", "");      if (aclnttrace >= 3 && cb != aclnt_cb_null)	cb = wrap (printreply, cb, name, out, rtp->print_res);    }    aclnt_cb cbw = wrap (this, &vnode_impl::doRPC_cb, 			l, outproc, out, cb, res);      if (!stream)      return rpcm->doRPC (me_, l, transport_program_1, TRANSPORTPROC_DORPC, 			  arg, res, cbw, 			  wrap(this, &vnode_impl::tmo, cb_tmo, 			       prog.progno, procno, arg->args.size ()));    else      return rpcm->doRPC_stream (me_, l, 				 transport_program_1, TRANSPORTPROC_DORPC, 				 arg, res, cbw);  }}

static voidstart (ptr<lsdctl_lsdparameters> p, clnt_stat err){  if (err)    fatal << "Couldn't connect to local lsd to get sync parameters: "	  << err << "/n";  ptr<locationtable> locations = New refcounted<locationtable> (1024);    chord_node ret;  bzero (&ret, sizeof (ret));  for (u_int i = 0; i < 3; i++)    ret.coords.push_back (0);  ret.r.hostname = p->addr.hostname;  ret.r.port = p->addr.port;  server = New refcounted<merkle_disk_server> (p->addr.port-1, p->nvnodes);  for (int i = 0; i < p->nvnodes; i++) {    ret.vnode_num = i;    ret.x = make_chordID (ret.r.hostname, ret.r.port, i);    ptr<location> n = New refcounted<location> (ret);    //dbname format: ID.".c"    str dbname = strbuf () << ret.x << ".c";    syncer *s = New syncer (locations, n, dbdir, p->adbdsock, dbname, 			    DHASH_CONTENTHASH);    syncers.push_back (s);    // create a merkle_tree and a merkle_server for this vnode/ctype    server->add_merkle_server (i, DHASH_CONTENTHASH,			       make_mserver (dbdir, dbname));    dbname = strbuf () << ret.x << ".n";    s = New syncer (locations, n, dbdir, p->adbdsock, dbname, 		    DHASH_NOAUTH, p->nreplica, p->nreplica);    syncers.push_back (s);    // create a merkle_tree and a merkle_server for this vnode/ctype    server->add_merkle_server (i, DHASH_NOAUTH,			       make_mserver (dbdir, dbname));  }}

static strsrp_prepend (const str &in){  if (!strchr (in, '@')) {    warnx << "Prepending '@' to '" << in << "' and using SRP/n";    return strbuf () << "@" << in;  } else {    return in;  }}

bool mysql_t::connect (const str &db, const str &u, const str &h,		  const str &pw, u_int prt, u_long fl){  if (!mysql_real_connect (&mysql, h, u, pw, db, prt, NULL, fl)) {    err = strbuf ("connection error: ") << mysql_error (&mysql);    return false;  }  return true;}

ref<afsusrroot>afsusrroot::alloc  (afsroot *r, sfs_aid aid, afsdir *p, str pn){  ref<afsusrroot> root (New refcounted<afsusrroot> (r, aid, p ? p : r, pn));  if (aid != sfsaid_nobody) {    root->link (afsaidfile::alloc (aid, strbuf () << aid << "/n"), ".aid");    //root->link (ctldiralloc (root, aid), ".ctl");  }  return root;}

void Console::showConsole(){    doShow = true;    //enable cursors    curs_set(1);    echo();    char charbuf[256];    while(doShow)    {        clear();        //print log buffer        int bufsize = int(buf.size());        int bufstart = 0;        if( bufsize >= CONSOLE_HEIGHT) bufstart = bufsize - CONSOLE_HEIGHT;        for(int i = 0; i < CONSOLE_HEIGHT; i++)        {            int bufindex = i + bufstart;            if(bufindex >= 0 && bufindex < bufsize) mvprintw(i + CONSOLE_HEIGHT - bufsize + bufstart, 0, "%s/n", buf[bufindex].c_str());            //else mvprintw(i, 0, "/n");        }        mvprintw(24,0,">");        getstr(charbuf);        std::string strbuf(charbuf);        log(std::string(">" + strbuf) );        //parse string buf        std::vector<std::string> words;        while(!strbuf.empty())        {            size_t pos = strbuf.find_first_of(' ', 0);            if(pos < strbuf.size())            {                words.push_back( strbuf.substr(0, pos) );                strbuf.erase(0, pos+1);            }            else            {                words.push_back(strbuf);                strbuf.clear();            }        }        parse(words);    }    curs_set(0);    noecho();}

voidrandom_set_seedfile (str path){  if (!path) {    if (seed) {      munmap (reinterpret_cast<char *> (seed), mapsize);      seed = NULL;    }    return;  }  if (path[0] == '~' && path[1] == '/') {    const char *home = getenv ("HOME");    if (!home) {      warn ("$HOME not set in environment/n");      return;    }    path = strbuf () << home << (path.cstr () + 1);  }  int fd = open (path, O_CREAT|O_RDWR, 0600);  if (fd < 0) {    warn ("%s: %m/n", path.cstr ());    return;  }  struct stat sb;  char c;  if (read (fd, &c, 1) < 0 || fstat (fd, &sb) < 0      || lseek (fd, mapsize - 1, SEEK_SET) == -1      || write (fd, "", 1) < 0) {    /* The read call avoids a segfault on NFS 2.  Specifically, if we     * are root and the random_seed file is over NFS 2, the open will     * succeed even though read returns EACCES.  If we map the file     * when we can't read it--bingo, segfault.  (In fact, on some OSes     * it also seems to cause a kernel panic when you examine the     * mmapped memory from the debugger.) */    close (fd);    warn ("%s: %m/n", path.cstr ());    return;  }  if ((sb.st_mode & 07777) != 0600)    warn ("%s: mode 0%o should be 0600/n", path.cstr (), sb.st_mode & 07777);  if (seed)    munmap (reinterpret_cast<char *> (seed), mapsize);  seed = mmap (NULL, (size_t) mapsize, PROT_READ|PROT_WRITE,	       MAP_FILE|MAP_SHARED, fd, 0);  if (seed == reinterpret_cast<void *> (MAP_FAILED)) {    warn ("mmap: %s: %m/n", path.cstr ());    seed = NULL;  }  else    rnd_input.update (seed, seedsize);  close (fd);}

voidpm_server::evaluate_polynomial (vec<cpayload> *res, 				const vec<crypt_ctext> *pccoeffs, 				const homoenc_pub *ppk,				const crypt_ctext *encone,				const str &x, ppayload *payload){  assert (res && pccoeffs && ppk && encone);  const vec<crypt_ctext> &ccoeffs = *pccoeffs;  const homoenc_pub &pk           = *ppk;  size_t deg = ccoeffs.size ();  // B.1.a  // Compute E(P(y))  bigint px = pk.pre_encrypt (x);  if (!px)    return;  // Require coefficient c[deg-1] = 1, to ensure that malicious client  // doesn't send over generate polynomial. See FNP04, 5.1  crypt_ctext cy = *encone;  // See polynomial::evaluate  // Coeffs sent over already don't include last element  while (deg) {    // y = y * x + coeff[i];    crypt_ctext tmp (pk.ctext_type ());    pk.mult (&tmp, cy, px);    pk.add  (&cy, tmp, ccoeffs[--deg]);  }  // B.1.b  // Compute E(rP(x))  pk.mult (&cy, cy, random_zn (pk.ptext_modulus ()));  // Generate payload  str buf = strbuf () << match << payload->ptxt;  crypt_ctext cpay (pk.ctext_type ());  //X warnx << "pay [" << hexdump (buf.cstr (), buf.len ()) << "]/n";  if (!pk.encrypt (&cpay, buf, true))    return;  // Compute E(rP(x) + (match || payload))  pk.add (&cy, cy, cpay);  cpayload pay;  pay.ctxt = cy;  // if P(x) != 0, resulting plaintext can be > buf.len, but  // we don't care, because the match check will fail  pay.ptsz = buf.len ();  res->push_back (pay);}

voidafsusrroot::finish (ref<setupstate> ss, int err){  if (!ss->dpt)    return;  if (!err)    err = srvinfo::geterr (ss->name);  if (err) {    ss->dpt->setres (nfsstat (err));    ss->dpt = NULL;    delaycb (15, wrap (afsdir_unlink, mkref (this), ss->name));    return;  }  if (!ss->revdone)    return;  afsnode *e = lookup (ss->name, NULL);  if (!e || e == ss->dpt)    e = afs_sfsroot->lookup (ss->name, NULL);  if (e) {    str name = ss->name;    unlink (name);    link (e, name);#if FIX_MNTPOINT    if (opt_fix_mntpoint) {      if (str res = e->readlink ())	ss->dpt->setres (res);      else {	warn << "afsusrroot::finish: shouldn't get here (please report bug)/n";	ss->dpt->setres (strbuf ("%s/%s", sfsroot, ss->name.cstr ()));	ss->dpt->setres (strbuf ("%s/" MPDOT "%s/r", sfsroot,				 ss->name.cstr ()));      }    }    else#endif /* FIX_MNTPOINT */      ss->dpt->setres (strbuf ("%s/%s", sfsroot, ss->name.cstr ()));  }  else    srvinfo::alloc (ss->name, wrap (mkref (this), &afsusrroot::finish, ss));}

 void cb (ptr<sha_query_res_t> res, clnt_stat err) {   if (err)     error_page (strbuf () << err);   else if (res->status == ADB_NOT_FOUND)     error_page ("Word not found in dictionary!");   else if (res->status != ADB_OK)     error_page ("Database errorr encountered!");   else     success_page (*res->res); }

static inline rpcstats *getstats (int progno, int procno){  str key = strbuf ("%d:%d", progno, procno);  rpcstats *stats = rpc_stats_tab[key];  if (!stats) {    stats = New rpcstats (key);    rpc_stats_tab.insert (stats);  }  return stats;}

voidsfs_suidserv (str prog, suidservcb cb){  str sock = strbuf ("%s/%s.sock", sfssockdir.cstr (), prog.cstr ());  sfs_unixserv (sock, wrap (suidaccept_cb, cb), 0660);  struct stat sb;  if (lstat (sock.cstr (), &sb) < 0 || (sb.st_mode & S_IFMT) != S_IFSOCK)    fatal << sock << ": bound but cannot stat/n";  if (!runinplace && sb.st_gid != sfs_gid)    chown (sock.cstr (), (uid_t) -1, sfs_gid);}

static inline const char *tracetime (){  static str buf ("");  if (aclnttime) {    timespec ts;    clock_gettime (CLOCK_REALTIME, &ts);    buf = strbuf (" %d.%06d", int (ts.tv_sec), int (ts.tv_nsec/1000));  }  return buf;}

intuvfs_open (){  int i = 0;  for (;;) {    int fd = open (str (strbuf ("/dev/uvfs%d", i)), O_RDWR);    if (fd >= 0 || errno == ENOENT)      return fd;  }}

strsuffix_sub (const char *s, const char *sfx1, const char *sfx2){  if (!s)    return NULL;  int len0, len1;  len0 = strlen (s);  len1 = strlen (sfx1);  if (len0 < len1 || !mystrcmp (s + len0 - len1, sfx1))    return NULL;  return (strbuf (str (s, len0 - len1)) << sfx2);}

static strrpc_decltype (const rpc_decl *d){  if (d->type == "string")    return strbuf () << "rpc_str<" << d->bound << ">";  else if (d->type == "opaque")    switch (d->qual) {    case rpc_decl::ARRAY:      return strbuf () << "rpc_opaque<" << d->bound << ">";      break;    case rpc_decl::VEC:      return strbuf () << "rpc_bytes<" << d->bound << ">";      break;    default:      panic ("bad rpc_decl qual for opaque (%d)/n", d->qual);      break;    }  else    switch (d->qual) {    case rpc_decl::SCALAR:      return d->type;      break;    case rpc_decl::PTR:      return strbuf () << "rpc_ptr<" << d->type << ">";      break;    case rpc_decl::ARRAY:      return strbuf () << "array<" << d->type << ", " << d->bound << ">";      break;    case rpc_decl::VEC:      return strbuf () << "rpc_vec<" << d->type << ", " << d->bound << ">";      break;    default:      panic ("bad rpc_decl qual (%d)/n", d->qual);    }}

stragent_userdir (u_int32_t uid, bool create){  int fd = open (".", O_RDONLY);  if (fd < 0) {    warn ("current working directory (.): %m/n");    return NULL;  }  const char *tmpdir = safegetenv ("TMPDIR");  if (!tmpdir || tmpdir[0] != '/')    tmpdir = "/tmp";    str ret;  struct stat sb;  uid_t myuid = getuid ();  if (chdir (tmpdir) < 0)    warn ("%s: %m/n", tmpdir);  else if (stat (".", &sb) < 0)    warn ("%s: %m/n", tmpdir);  else if ((sb.st_mode & 022) && !(sb.st_mode & 01000))    warn ("bad permissions on %s; chmod +t or set TMPDIR elsewhere", tmpdir);  else if (myuid == uid)    ret = agent_userdir_search (tmpdir, uid, create);  else if (!myuid) {    int fds[2];    if (pipe (fds) < 0)      warn ("pipe: %m/n");    else if (pid_t pid = afork ()) {      close (fds[1]);      strbuf sb;      while (sb.tosuio ()->input (fds[0]) > 0)	;      close (fds[0]);      int status = 1;      if (!waitpid (pid, &status, 0) && !status)	ret = sb;    }    else {      close (fds[0]);      _exit (setuid (uid)	     || !(ret = agent_userdir_search (tmpdir, uid, create))	     || (write (fds[1], ret, ret.len ())	         != implicit_cast<ssize_t> (ret.len ())));    }  }  rc_ignore (fchdir (fd));  close (fd);  return ret ? str (strbuf ("%s/", tmpdir) << ret) : str (NULL);}

voidauthcursor::find_gids_user (vec<u_int32_t> *gids, str user){  user = strbuf () << "u=" << user;  for (reset (); next ();)    if (ae.type == SFSAUTH_GROUP)      for (sfs_groupmember *gmp = ae.groupinfo->members.base ();	   gmp < ae.groupinfo->members.lim (); gmp++)	if (*gmp == user) {	  gids->push_back (ae.groupinfo->id);	  break;	}}

static strunpackmethod (const rpc_decl *d){   if (d->type == "string") {     return "u.unpack_string()";   } else if (d->type == "opaque") {     switch (d->qual) {     case rpc_decl::ARRAY:       return strbuf () << "u.unpack_fopaque(" << d->bound << ")";       break;     case rpc_decl::VEC:       return "u.unpack_opaque()";       break;     default:       panic ("bad rpc_decl qual for opaque (%d)/n", d->qual);       break;     }   } else {     switch (d->qual) {     case rpc_decl::SCALAR:       return unpackitem(d->type);       break;     case rpc_decl::PTR:       return strbuf () << "unpack_ptr(u, lambda : "                        << unpackitem(d->type) << ")";       break;     case rpc_decl::ARRAY:       return strbuf () << "u.unpack_farray(" << d->bound                        << ", lambda : " << unpackitem(d->type) << ")";       break;     case rpc_decl::VEC:       return strbuf () << "u.unpack_array(lambda : "                        << unpackitem(d->type) << ")";       break;     default:       panic ("bad rpc_decl qual (%d)/n", d->qual);     }   }}

straekey (const sfsauth_dbrec &ae){  switch (ae.type) {  case SFSAUTH_USER:    return strbuf () << "USER:" << ae.userinfo->name;  case SFSAUTH_GROUP:    return strbuf () << "GROUP:" << ae.groupinfo->name;  case SFSAUTH_CACHEENTRY:    return strbuf () << "CACHE:" << ae.cacheentry->key;  default:    {      static rxx knrx ("^[^:]*:[^:]*");      str astr = authdbrec2str (&ae);      if (!astr)	return NULL;      if (!knrx.search (astr))	panic << "missing colon: " << astr << "/n";      return knrx[0];    }  }}

voidafslink::setres (nfsstat err){  assert (err);#ifdef __linux__  /* XXX -- linux ignores the return status of a readlink RPC */  res.set_status (NFS_OK);  *res.data = strbuf (":: ") << strerror (err);#else /* !linux */    res.set_status (err);#endif /* !linux */  reply ();}

boolauthclnt::update_checksig (svccb *sbp, update_info &i, dbfile *cdbp){  str reqxdr = xdr2str (i.argp->req);  if (i.argp->newsig) {    str e;    if (!sfscrypt.verify (i.argp->req.rec.userinfo->pubkey, *(i.argp->newsig), 			  reqxdr, &e)) {      *i.res.errmsg = str (strbuf ("new signature: " << e));      sbp->replyref (i.res);      return false;    }  }  else if (!(i.opts & SFSUP_KPPK) && !i.admin) {    *i.res.errmsg = "Missing signature with new public key.";    sbp->replyref (i.res);    return false;  }  if (i.argp->authsig) {    str e;    if (!sfscrypt.verify (i.cdbr.userinfo->pubkey, *(i.argp->authsig), 			  reqxdr, &e)) {      *i.res.errmsg = str (strbuf ("old signature: " << e));      sbp->replyref (i.res);      return false;    }  }  else if (!cdbp->allow_unix_pwd || i.ur->authtype != SFS_UNIXPWAUTH) {    *i.res.errmsg = "digital signature required";    sbp->replyref (i.res);    return false;  }  else    i.admin = false;  return true;}

static voidafs_init2 (cbv cb, int stat, u_int64_t dev){  if (stat)    fatal ("mount (%s): %s/n", sfsroot, strerror (stat));  root_dev = dev;  update_devdb ();  nfs_fh fh;  afs_wait->mkfh (&fh);  mnt_mount (dup (afsfd), "(sfswait)", strbuf ("%s/.mnt/wait", sfsroot),	     v3flag | NMOPT_NOAC | NMOPT_RO | NMOPT_SOFT,	     nfs_fh2tobytes (fh), wrap (afs_init3, cb));}

voiddhash_download::add_data (str sdata, int off){    int len = sdata.len ();    const char *data = sdata.cstr ();    if ((unsigned)(off + len) > (u_int)buf_len)        fail (strbuf ("bad chunk: off %d, len %d, block %ld",                      off, len, buf_len));    else {        memcpy (buffer + off, data, len);        bytes_read += len;    }}

boolclient::get_userkey (svccb *sbp, str &pk){  u_int32_t authno = sbp->getaui ();  str *key;  pk = "";  /* changed by kaminsky from what savvides had */  if (authno > 0) {    if (authno >= keytab.size () || !(key = &keytab[authno])) {      warn << "authno does not correspond to a user with a PK hash/n";      return false;    }    pk = strbuf () << TYPEPK << ACLDIV << *key;   }  else if (authno == 0)    pk = strbuf () << TYPESYS << ACLDIV << SYS_ANONYMOUS;  else    return false;  return true;}

intmain (int argc, char **argv){  setprogname (argv[0]);  char *dir = getcwd (NULL, PATH_MAX);  str aiodpath (strbuf ("%s/../async/aiod", dir));  free (dir);  for (int i = x; i-- > 0;) {    aiod *a = New aiod (1, 0x10000, 0x10000, false, aiodpath);    New refcounted<aiotst> (a);  }  amain ();}

static boolparse_service (vec<str> &av, extension *e, str errpref){  u_int32_t snum;  str usage = strbuf ()    << errpref << ": usage: Service num prog [arg ...]/n"    << errpref << ":        Service num -u path/n"    << errpref << ":        Service num -t server [port]/n";  if (av.size () < 3 || !convertint (av[1], &snum)) {    warn << usage;    return false;  }  if (!e) {    warn << errpref	 << ": Service must follow Release or Extensions/n";    return false;  }  if (e->srvtab[snum]) {    warn << errpref	 << ": Service " << snum << " already defined/n";    return false;  }  av.pop_front ();  av.pop_front ();  if (av[0][0] != '-') {    av[0] = fix_exec_path (av[0]);    sfssrv *ss = exectab[av];    if (!ss)      ss = New sfssrv_exec (av);    e->srvtab.insert (snum, ss);    return true;  }  else if (av[0] == "-u" && av.size () == 2) {    sfssrv *ss = New sfssrv_sockpath (av[1]);    e->srvtab.insert (snum, ss);    return true;  }  else if (av[0] == "-t" && av.size () >= 2 && av.size () <= 3) {    u_int16_t port = 0;    if (av.size () == 2 || convertint (av[2], &port)) {      sfssrv *ss = New sfssrv_proxy (av[1], port);      e->srvtab.insert (snum, ss);      return true;    }  }  warn << usage;  return false;}

intmain (int argc, char **argv){  bool opt_nodaemon = false;  setprogname (argv[0]);  int ch;  while ((ch = getopt (argc, argv, "df:S:")) != -1)    switch (ch) {    case 'd':      opt_nodaemon = true;      break;    case 'f':      if (configfile)	usage ();      configfile = optarg;      break;    case 'S':      {	str sfsconf (strbuf ("SFS_CONFIG=%s", optarg));	xputenv (const_cast<char*>(sfsconf.cstr()));      }    case '?':    default:      usage ();    }  argc -= optind;  argv += optind;  if (argc > 1)    usage ();  sfsconst_init ();  if (!configfile)    configfile = sfsconst_etcfile_required ("sfssd_config");  parseconfig ();  if (!revocationdir)    revocationdir = sfsdir << "srvrevoke";  if (!opt_nodaemon && !builddir) {    daemonize ();    sigcb (SIGINT, wrap (termsig, SIGINT));    sigcb (SIGTERM, wrap (termsig, SIGTERM));  }  warn ("version %s, pid %d/n", VERSION, int (getpid ()));  sigcb (SIGHUP, wrap (restart));  launchservers ();  amain ();}