void
dhashclient::retrieve (bigint key, dhash_ctype ct, cb_cret cb, str& data,
		       ptr<option_block> options)
{
  ref<dhash_retrieve_res> res = New refcounted<dhash_retrieve_res> (DHASH_OK);
  dhash_retrieve_arg arg;
  arg.blockID = key;
  arg.ctype = ct;
  arg.options = 0;
  if (options) {
    arg.options = options->flags;
    if (options->flags & DHASHCLIENT_GUESS_SUPPLIED) {
      arg.guess = options->guess;
      //warn << "starting with guess: " << arg.guess << "\n";
      //warn << "using guess\n";
		}
  }

	// Praveen
	if (data.len()) {
  	arg.data.setsize (data.len());
  	memcpy (arg.data.base (), data.cstr(), data.len());
	}
	
  gwclnt->call (DHASHPROC_RETRIEVE, &arg, res, 
		wrap (this, &dhashclient::retrievecb, cb, key, res));
}
Exemple #2
0
str
html_wss (str in)
{
  if (!in) return in;
  mstr out (in.len ());
  char *op = out.cstr ();
  const char *ip = in.cstr ();
  const char *ep = ip + in.len ();
  
  bool eat_ws_state = false;
  for ( ; ip < ep; ip++) {
    if (isspace (*ip)) {
      if (!eat_ws_state) {
	eat_ws_state = true;
      }
    } else {
      if (eat_ws_state) {
	*op++ = ' ';
	eat_ws_state = false;
      }
      *op++ = *ip;
    }
  }
  if (eat_ws_state) { *op++ = ' '; }
  out.setlen (op - out.cstr ());
  return out;
}
Exemple #3
0
void
dhblock_keyhash_srv::real_store (chordID key, str od, str nd, u_int32_t exp, cb_dhstat cb)
{
  u_int32_t v1 = dhblock_keyhash::version (nd.cstr (), nd.len ());
  if (od.len ()) {
    u_int32_t v0 = dhblock_keyhash::version (od.cstr (), od.len ());
    if (v0 > v1) {
      chordID p = node->my_pred ()->id ();
      chordID m = node->my_ID ();
      if (betweenrightincl (p, m, key))
	cb (DHASH_STALE);
      else
	cb (DHASH_RETRY);
    } else {
      info << "db delete: " << key << "\n";
      db->remove (key, v0, 
		  wrap (this, &dhblock_keyhash_srv::delete_cb, key, 
			nd, v1, exp, cb));
    }
  } else {
    info << "db write: " << node->my_ID ()
	 << " N " << key << " " << nd.len () << "\n";
    db_store (key, nd, v1, exp, cb);
  }
}
inline str
group_prefix (str s, str prefix)
{
  if (s.len () <= prefix.len () || s[prefix.len ()] != '.'
      || memcmp (s.cstr (), prefix.cstr (), prefix.len ()))
    return NULL;
  return substr (s, prefix.len () + 1);
}
bool
siglog (const str &line)
{
  if (!line) return false;
  int n = write (logfd, line.cstr (), line.len ());
  if (n < int (line.len ())) 
    return false;
  return true;
}
Exemple #6
0
void
suio_print (suio *uio, const str &s)
{
  if (s.len () <= suio::smallbufsize)
    uio->copy (s.cstr (), s.len ());
  else {
    uio->print (s.cstr (), s.len ());
    uio->iovcb (wrap (&s.b.Xplug, s.b.Xleak ()));
  }
}
Exemple #7
0
str
my_tolower (const str &in)
{
  if (!in) return in;

  mstr out (in.len ());
  for (size_t i = 0; i < in.len (); i++) {
    out[i] = tolower (in[i]);
  }
  out.setlen (in.len ());
  return out;
}
Exemple #8
0
str
trunc_at_first_null (const str &s)
{
  assert (s);

  const char *cp;
  size_t len = s.len ();
  size_t l;
  const char nullc = '\0';

  // Figure out if a '\0' or the end-of-string comes first.
  for (cp = s.cstr (), l = 0; *cp != nullc && l < len; cp++, l++);

  str ret;

  if (*cp == nullc) {
    
    // The most likely outcome
    if (l == len) ret = s;

    // There was a '\0' inside the string
    else ret = s.cstr ();

  } else {
   
    // String is not null terminated!
    mstr m (len + 1);
    memcpy (m.cstr (), s.cstr (), len);
    m[len] = nullc;
    ret = m;
  }

  return ret;
}
Exemple #9
0
bool
basename_dirname (const str &in, str *d, str *b)
{
  size_t l = in.len ();

  if (l == 0) {
    *d = *b = NULL;
    return false;
  }

  bool ret = (in[0] == '/');
  const char *bp = in.cstr ();
  const char *ep = bp + l - 1;
  const char *p;
  for ( p = ep; p >= bp && *p != '/'; p--) ;

  // Set the basename if possible
  if (p == ep) {
    *b = NULL;
  } else {
    *b = str (p + 1);
  }

  // if there were multiple slashes keep backing up
  for ( ; p >= bp && *p == '/' ; p-- );

  if (p >= bp) {
    assert (*p != '/');
    *d = str (bp, p - bp + 1);
  } else {
    *d = NULL;
  }
  
  return ret;
}
Exemple #10
0
bool
is_safe (const str &d)
{
  if (!d || d[0] == '.' || d[d.len () - 1] == '.' || safe_rxx.search (d))
    return false;
  return true;
}
Exemple #11
0
sth_t
mysql_t::prepare (const str &q, u_int l_opts)
{
  if (l_opts & AMYSQL_DEFAULT)
    l_opts = opts;
  sth_t *rp = cache[q];
  if (rp) return (*rp);

  sth_t r = NULL;
  if (l_opts & AMYSQL_PREPARED) {
#if defined(HAVE_MYSQL_BINDFUNCS) && defined(HAVE_MYSQL_BIND)
    MYSQL_STMT *s = mysql_stmt_init (&mysql);
    if (!s) {
      err = strbuf ("MySQL ran out of memory on statment init: ")
	<< mysql_error (&mysql);
      return NULL;
    }

    if (mysql_stmt_prepare (s, q, q.len ())) {
      err = strbuf ("could not prepare query (") 
	<< q << "): " << mysql_error (&mysql);
      return NULL;
    }
    r = sth_prepared_t::alloc (s, q, l_opts);
#endif // HAVE_MYSQL_BINDFUNCS && HAVE_MYSQL_BIND
  } else {
    ptr<sth_parsed_t> r2 = sth_parsed_t::alloc (&mysql, q, l_opts);
    if (!r2->parse ())
      return NULL;
    r = r2;
  }
  if (!(l_opts & AMYSQL_NOCACHE))
    cache.insert (q, r);
  return r;
}
Exemple #12
0
//for looking up self-certifying hostnames in certprog interface
int
path2sch (str path, str *sch)
{
  *sch = NULL;

  if (!path || !path.len ())
    return ENOENT;
  
  if (sfs_parsepath (path)) {
    *sch = path;
    return 0;
  }

  str lookup;
  if (path[0] == '/')
    lookup = path;
  else
    lookup = strbuf () << sfsroot << "/" << path;

  str result = pathiterate (lookup, sch, 0, true);
  //  warn << "RESULT: " << result << "\n";

  if (errno == EINVAL)
    errno = 0;
//   if (*sch)
//     warn << "RETURNING: " << *sch << "\n";
//   warn << "RETURNING ERROR CODE: " << strerror (errno) << "\n";
  return errno;
}
Exemple #13
0
void
outputter_t::output_str (str s)
{
  if (_mode == OUTPUT_TREADMILL) {
    static rxx x ("\n");
    vec<str> v;
    split (&v, x, s);
    for (u_int i = 0; i < v.size (); i++) {
      output_line_number ();
      _output_str (v[i], "\n");
    }
  } else {

    // we might have set up a defered output_line_number from
    // within switch_to_mode; now is the time to do it.
    if (s.len () && _do_output_line_number) {
      output_line_number ();
      _do_output_line_number = false;
    }

    _output_str (s, NULL);
    if (_mode == OUTPUT_PASSTHROUGH)
      _lineno += count_newlines (s);
  }
}
Exemple #14
0
wide_str_t::wide_str_t (str utf8_in)
{
  if (utf8_in) {
    _init (utf8_in.len ());
    mbstate_t state;
    memset (&state, 0, sizeof (state));
    const char *src = utf8_in.cstr ();
    setlocale (LC_CTYPE, "en_US.UTF-8");
    ssize_t ret = mbstowcs (_buf->base (), src, _buf->size ());
    if (ret < 0) {
      _err = true;
      _buf = NULL;
      _len = 0;
    } else {
      _len = ret;
      if (0 && src) {
	warn << "XX failed to completely convert string ('" 
	     << utf8_in << "'): " 
	     << "expected " << _len << " bytes, but only converted "
	     << (src - utf8_in.cstr ()) << "\n";
	_err = true;
      } else {
	_err = false;
      }
    }
  }
}
void
resolv_conf::reload_cb (ref<bool> d, bool failure, str newres)
{
  if (*d)
    return;

  nbump = 0;
  reload_lock = false;
  last_reload = timenow;
  if (!newres) {
    warn ("resolv_conf::reload_cb: fork: %m\n");
    setsock (true);
    return;
  }
  if (newres.len () != sizeof (_res)) {
    warn ("resolv_conf::reload_cb: short read\n");
    setsock (true);
    return;
  }

  char oldnsaddr[sizeof (_res.nsaddr_list)];
  memcpy (oldnsaddr, _res.nsaddr_list, sizeof (oldnsaddr));
  memcpy (&_res, newres, sizeof (_res));
  if (memcmp (oldnsaddr, _res.nsaddr_list, sizeof (oldnsaddr))) {
    warn ("reloaded DNS configuration (resolv.conf)\n");
    ns_idx =  _res.nscount ? _res.nscount - 1 : 0;
    //nbump = 0;
    last_reload = timenow;
    setsock (true);
  }
  else
    setsock (failure);
}
Exemple #16
0
int
split (vec<str> *out, rxx pat, str expr, size_t lim, bool emptylast)
{
  const char *p = expr;
  const char *const e = p + expr.len ();
  size_t n;
  if (out)
    out->clear ();

  // check p < e to see that we're not dealing with an empty
  // string (especially since x? matches "").
  for (n = 0; p < e && n + 1 < lim; n++) {
    if (!pat._exec (p, e - p, 0)) {
      return 0;
    }
    if (!pat.success ())
      break;
    if (out)
      out->push_back (str (p, pat.start (0)));
    p += max (pat.end (0), 1);
  }

  if (lim && (p < e || emptylast)) {
    n++;
    if (out) {
      out->push_back (str (p, e - p));
    }
  }
  return n;
}
Exemple #17
0
bool
repl_t::parse (str in)
{
  const char *bp = in.cstr ();
  const char *ep = bp + in.len ();
  const char *last = bp;
  size_t inc = 1;

  for (const char *p = bp; p < ep; p += inc) {
    bool is_dig = false;
    inc = 1;
    
    if (p == ep - 1 || *p != '$') { /* noop */ }

    else if (p[1] == '$' || (is_dig = (isdigit (p[1])))) {

      add_str (bp, last, p, ep);
      inc = 2;

      if (is_dig) {
	add_capture (p[1] - '0');
	last = p + 2;
      } else {
	last = p + 1;
      }
    }

  }
  add_str (bp, last, ep, ep);
  return true;
}
Exemple #18
0
void
pub3::msgpack::outbuf_t::encode_str (str s)
{
  assert (s);
  size_t l = s.len ();
  encode_raw_len (l, 0xa0, 0xda, 0xdb);
  put_str (s);
}
Exemple #19
0
void
acl::fix_aclstr (str s, char *buf)
{
  char sbuf[ACLSIZE];
  int min = (ACLSIZE > s.len ()) ? s.len () : ACLSIZE;
  bzero (buf, ACLSIZE);
  bzero (sbuf, ACLSIZE);
  
  memcpy (sbuf, s.cstr (), min);

  str aclend (ENDACL "\n");
  int tail = aclend.len ();
  char *c = strstr (sbuf, ENDACL);
  int p = c ? c - sbuf : 0;

  int total = p ? p + tail : s.len () + tail;
  if (!p)
    warn << "ACLEND not found in ACL \n";
  
  if (total <= ACLSIZE) {
    memcpy (buf, s.cstr (), p);
    memcpy (buf + p, aclend.cstr (), aclend.len ());
    return;
  }

  if (total > ACLSIZE) {
    if (p)
      warn << "ACLEND found at position " << p << "\n";
    else
      warn << "ACLEND not found in ACL \n";

    warn << "ACL does not fit in buffer. Truncating \n";
    if ( p && p < (ACLSIZE - tail)) {
      warn << "Removing garbage after ACLEND \n";
      memcpy (buf, s.cstr (), p);
      memcpy (buf + p, aclend.cstr (), aclend.len ());
      return;
    }
    else {
      memcpy (buf, s.cstr (), ACLSIZE - tail);
      memcpy (buf + ACLSIZE - tail, aclend.cstr (), tail);
      return;
    }
  }
}
Exemple #20
0
str 
dir_standardize (const str &s)
{
  const char *bp = s.cstr ();
  const char *ep = bp + s.len () - 1;
  for ( ; bp <= ep && *ep == '/'; ep--) ;
  ep++;
  return str (bp, ep - bp);
}
Exemple #21
0
void 
dhblock_keyhash_srv::delete_cb (chordID k, str d, u_int32_t v, u_int32_t exp, cb_dhstat cb, adb_status stat) 
{
  assert (stat == ADB_OK);
  info << "db write: " << node->my_ID ()
       << " U " << k << " " << d.len () << "\n";
  
  db_store (k, d, v, exp, cb);
}
Exemple #22
0
bool
has_null_byte (const str &s)
{
  bool ret = false;
  for (size_t i = 0; !ret && i < s.len (); i++) {
    if (!s[i]) { ret = true; }
  }
  return ret;
}
Exemple #23
0
static int
start_log_to_file (const str &line, const str &logfile, int flags, mode_t m)
{
  int fd;
  int n;
  if ((fd = open (logfile.cstr (), flags, m)) < 0) {
    warn ("%s: %m\n", logfile.cstr ());
    fd = errfd;
  } else {
    warn << "Logging via logfile: " << logfile << "\n";
    if (line) {
      n = write (fd, line.cstr (), line.len ());
      if (n < (int (line.len ()))) 
	warn << logfile << ": write to logfile failed\n";
    }
  } 
  return fd;
}
Exemple #24
0
sfs_core::select_policy_t 
sfs_core::select_policy_from_str (const str &s)
{
  sfs_core::select_policy_t ret = SELECT_NONE;
  if (s && s.len () > 0) {
    char c = s[0];
    ret = select_policy_from_char (c);
  }
  return ret;
}
Exemple #25
0
str
trunc_after_null_byte (str s)
{
  str ret;
  size_t l;
  if (!s) { ret = s; }
  else if ((l = strlen (s.cstr())) == s.len ()) { ret = s; }
  else { ret = str (s.cstr (), l); }
  return ret;
}
Exemple #26
0
static bool
find_non_std_char (const str &s)
{
  const u_int8_t *p = reinterpret_cast<const u_int8_t *> (s.cstr ());
  const u_int8_t *ep = p + s.len ();
  for ( ; p < ep; p++) {
    if (*p <= 0x1f || *p > 0x7f) { return true; }
  }
  return false;
}
Exemple #27
0
u_int count_newlines (str s)
{
  const char *end = s.cstr () + s.len ();
  u_int c = 0;
  for (const char *cp = s.cstr (); cp < end; cp++) {
    if (*cp == '\n')
      c++;
  }
  return c;
}
Exemple #28
0
void printtable (ptr<locationtable> locs, str header, str prefix)
{
  if (header.len ())
    warnx << header << "\n";
  
  ptr<location> l = locs->first_loc ();
  while (l) {
    warnx << prefix << l->id () << " " << l->alive () << "\n";
    l = locs->next_loc (l->id ());
  }
}
Exemple #29
0
bool 
cicmp (const str &s1, const char *c2, u_int l)
{
  if (s1.len () != l)
    return false;
  const char *c1 = s1.cstr ();
  for (u_int i = 0; i < l; i++)
    if (tolower (c1[i]) != tolower (c2[i]))
      return false;
  return true;
}
dnsreq::dnsreq (resolver *rp, str n, u_int16_t t, bool search)
  : ntries (0), resp (rp), usetcp (false), constructed (false),
    error (0), type (t)
{
  while (n.len () && n[n.len () - 1] == '.') {
    search = false;
    n = substr (n, 0, n.len () - 1);
  }
  if (!search) {
    srchno = -1;
    basename = NULL;
    name = n;
  }
  else {
    srchno = 0;
    basename = n;
    name = NULL;
  }
  start (false);
  constructed = true;
}