Esempio n. 1
0
static DICT *dict_cdbq_open(const char *path, int dict_flags)
{
    DICT_CDBQ *dict_cdbq;
    struct stat st;
    char   *cdb_path;
    int     fd;

    cdb_path = concatenate(path, CDB_SUFFIX, (char *) 0);

    if ((fd = open(cdb_path, O_RDONLY)) < 0)
	return (dict_surrogate(DICT_TYPE_CDB, path, O_RDONLY, dict_flags,
			       "open database %s: %m", cdb_path));

    dict_cdbq = (DICT_CDBQ *) dict_alloc(DICT_TYPE_CDB,
					 cdb_path, sizeof(*dict_cdbq));
#if defined(TINYCDB_VERSION)
    if (cdb_init(&(dict_cdbq->cdb), fd) != 0)
	msg_fatal("dict_cdbq_open: unable to init %s: %m", cdb_path);
#else
    cdb_init(&(dict_cdbq->cdb), fd);
#endif
    dict_cdbq->dict.lookup = dict_cdbq_lookup;
    dict_cdbq->dict.close = dict_cdbq_close;
    dict_cdbq->dict.stat_fd = fd;
    if (fstat(fd, &st) < 0)
	msg_fatal("dict_dbq_open: fstat: %m");
    dict_cdbq->dict.mtime = st.st_mtime;
    dict_cdbq->dict.owner.uid = st.st_uid;
    dict_cdbq->dict.owner.status = (st.st_uid != 0);
    close_on_exec(fd, CLOSE_ON_EXEC);

    /*
     * Warn if the source file is newer than the indexed file, except when
     * the source file changed only seconds ago.
     */
    if (stat(path, &st) == 0
	&& st.st_mtime > dict_cdbq->dict.mtime
	&& st.st_mtime < time((time_t *) 0) - 100)
	msg_warn("database %s is older than source file %s", cdb_path, path);

    /*
     * If undecided about appending a null byte to key and value, choose to
     * try both in query mode.
     */
    if ((dict_flags & (DICT_FLAG_TRY1NULL | DICT_FLAG_TRY0NULL)) == 0)
	dict_flags |= DICT_FLAG_TRY0NULL | DICT_FLAG_TRY1NULL;
    dict_cdbq->dict.flags = dict_flags | DICT_FLAG_FIXED;
    if (dict_flags & DICT_FLAG_FOLD_FIX)
	dict_cdbq->dict.fold_buf = vstring_alloc(10);

    myfree(cdb_path);
    return (&dict_cdbq->dict);
}
Esempio n. 2
0
// TODO: use mmap instead of read.. much faster!
SDB_VISIBLE Sdb* sdb_new (const char *dir, int lock) {
	Sdb* s;
	if (lock && !sdb_lock (sdb_lockfile (dir)))
		return NULL;
	s = malloc (sizeof (Sdb));
	if (dir && *dir) {
		s->dir = strdup (dir);
		s->fd = open (dir, O_RDONLY|O_BINARY);
		// if (s->fd == -1) // must fail if we cant open for write in sync
	} else {
		s->dir = NULL;
		s->fd = -1;
	}
	s->fdump = -1;
	s->ndump = NULL;
	s->ns = ls_new ();
	s->ht = ht_new ();
	s->lock = lock;
	s->expire = 0LL;
	//s->ht->list->free = (SdbListFree)sdb_kv_free;
	// if open fails ignore
	cdb_init (&s->db, s->fd);
	cdb_findstart (&s->db);
	return s;
}
Esempio n. 3
0
int main(int argc, char **argv, char **envp) {
  uint8_t buf[1024];
  cdb_t cdb;
  char *key;
  uint32_t len;
  uint32_t r;
  uint32_t pos;
  uint32_t skip = 0;
  char *skip_str;
  
  if (!*argv || !*++argv)
    usage();
  key = *argv;
  
  skip_str = *++argv;
  if (skip_str) {
    if (sscanf(skip_str, "%" PRIu32, &skip) != strlen(skip_str))
      usage();
  }
  
  /* Initialize the cdb struct using stdin as it's file descriptor. */
  if (cdb_init(&cdb, 0) == -1)
    strerr_die2x(111, FATAL, "failed to initialize cdb");
    
  for (;;) {
    r = cdb_find_next(&cdb, key, strlen(key));
    if (r == -1)
      strerr_die2sys(111, FATAL, "unable to read input: ");
    if (!r)
      _exit(100);
      
    if (!skip)
      break;
    skip--;
  }
  
  /* If there's a record in the cdb file, then the cdb structs dlen property
   * will be set to a non-zero value and it's position will be set to the
   * offset in the file containing the data.  Read the data in chunks and send
   * it to stdout. */
  len = cdb.dlen;
  pos = cdb.dpos;
  while (len > 0) {
    r = sizeof(buf);
    if (r > len)
      r = len;
    if (cdb_read(buf, r, &cdb, pos) == -1)
      strerr_die2sys(111, FATAL, "unable to read input: ");
    if (bio_put(bio_1, buf, r) == -1)
      strerr_die2sys(111, FATAL, "unable to write output: ");
    pos += r;
    len -= r;
  }
  if (bio_flush(bio_1) == -1)
    strerr_die2sys(111, FATAL, "unable to write output: ");
    
  cdb_free(&cdb);
  
  return 0;
}
Esempio n. 4
0
int
main(int argc, char* argv[]) {
  int fd;
  static struct cdb c;
  errmsg_iam("cdbget");
  if(argc < 3)
    die(1, "usage: cdbget data.cdb key");
  fd = open(argv[1], O_RDONLY | O_BINARY);
  if(fd == -1)
    diesys(1, "open");
  cdb_init(&c, fd);
  if(cdb_find(&c, argv[2], str_len(argv[2])) > 0) {
    do {
      char* x = malloc(cdb_datalen(&c));
      if(!x)
        die(1, "out of memory");
      if(cdb_read(&c, x, cdb_datalen(&c), cdb_datapos(&c)) == -1)
        diesys(1, "cdb_read");
      buffer_put(buffer_1, x, cdb_datalen(&c));
      buffer_put(buffer_1, "\n", 1);
      free(x);
    } while(cdb_findnext(&c, argv[2], str_len(argv[2])) > 0);
  }
  buffer_flush(buffer_1);
}
Esempio n. 5
0
int respond(char *q,char qtype[2],char ip[4])
{
  int fd;
  int r;
  char key[6];

  tai_now(&now);
  fd = open_read("data.cdb");
  if (fd == -1) return 0;
  cdb_init(&c,fd);

  byte_zero(clientloc,2);
  key[0] = 0;
  key[1] = '%';
  byte_copy(key + 2,4,ip);
  r = cdb_find(&c,key,6);
  if (!r) 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;
  if (r && (cdb_datalen(&c) == 2))
    if (cdb_read(&c,clientloc,2,cdb_datapos(&c)) == -1) return 0;

  r = doit(q,qtype);

  cdb_free(&c);
  close(fd);
  return r;
}
Esempio n. 6
0
int main (int argc, char *argv[])
{
    const char *p;
    const char *end;
    struct cdb c;
    struct stat st;
    int fd;
    const unsigned int klen = 8;
    /* input stream must have keys of constant len 8 */

    if (argc < 3) return -1;

    /* open mcdb */
    if ((fd = open(argv[1], O_RDONLY, 0777)) == -1) {perror("open"); return -1;}
    memset(&c, '\0', sizeof(struct cdb));
    cdb_init(&c, fd);

    /* open input file */
    if ((fd = open(argv[2], O_RDONLY, 0777)) == -1) {perror("open"); return -1;}
    if (fstat(fd, &st) != 0)                        {perror("fstat");return -1;}
    p = (const char *)mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
    if (p == MAP_FAILED)                            {perror("mmap"); return -1;}
    close(fd);

    /* read each key from input mmap and query mcdb
     * (no error checking since key might not exist) */
    for (end = p+st.st_size; p < end; p += klen)
        cdb_find(&c, p, klen);
    return 0;
}
Esempio n. 7
0
int rules(void (*callback)(char *,unsigned int),int fd,char *ip,char *host,char *info)
{
  int r;
  cdb_init(&c,fd);
  r = doit(callback,ip,host,info);
  cdb_free(&c);
  return r;
}
Esempio n. 8
0
static struct cdb* open_cdb(const str* filename)
{
  int fd;
  struct cdb* c;
  if ((c = malloc(sizeof *c)) == 0) return 0;
  fd = open(filename->s, O_RDONLY);
  cdb_init(c, fd);
  if (!dict_add(&cdb_files, filename, c)) return 0;
  return c;
}
Esempio n. 9
0
int respond(char *q,char qtype[2],char ip[4])
{
    int fd;
    int result;

    fd = open_read("data.cdb");
    if (fd == -1) return 0;
    cdb_init(&c,fd);
    result = doit(q,qtype,ip);
    cdb_free(&c);
    close(fd);
    return result;
}
Esempio n. 10
0
static int _OS_CDBOpen(ListNode *lnode)
{
    int fd;
    if (lnode->loaded != 1) {
        if ((fd = open(lnode->cdb_filename, O_RDONLY)) == -1) {
            merror(OPEN_ERROR, ARGV0, lnode->cdb_filename, errno, strerror (errno));
            return -1;
        }
        cdb_init(&lnode->cdb, fd);
        lnode->loaded = 1;
    }
    return 0;
}
Esempio n. 11
0
static int
dbl_init (void)
{
    extern struct cdb bl;    /* dns block list */

    int fd = open_read ("dnsbl.cdb");
    if (fd == -1)
        return 0;

    cdb_init (&bl, fd);
    close (fd);

    return 1;
}
Esempio n. 12
0
static int
__nss_cdb_dosetent(struct nss_cdb *dbp) {
  int fd;

  fd = open(dbp->dbname, O_RDONLY);
  if (fd < 0)
    return 0;
  if (cdb_init(&dbp->cdb, fd) != 0) {
    close(fd);
    return 0;
  }
  close(fd);
  dbp->lastpos = 2048; /* cdb_seqinit() */
  return 1;
}
Esempio n. 13
0
VALUE mCDB_Reader_get(VALUE self, VALUE key) {
  struct cdb db;
  VALUE value;
  StringValue(key);
  int fd = open_cdb_fd(self);
  size_t vlen;
  cdb_init(&db,fd);
  if(cdb_find(&db,RSTRING_PTR(key),RSTRING_LEN(key)) > 0) {
    vlen = cdb_datalen(&db);
    value = rb_str_buf_new(vlen);
    cdb_read(&db,RSTRING_PTR(value),vlen,cdb_datapos(&db));
    rb_str_set_len(value,vlen);
    return value;
  }
  close(fd);
  return Qnil;
}
Esempio n. 14
0
main()
{
	uint32 eod;
	uint32 klen;
	uint32 dlen;
	seek_pos rest;
	int r;

	cdb_init(&c,0);

	getnum(&eod);

	numrecords = (c.size - eod) / 8; 

	putnum(numrecords);
	putflush();
	_exit(0);
}
Esempio n. 15
0
static PyObject *
_wrap_cdb_init(int fd) {  /* constructor implementation */

  CdbObject *self;

  self = PyObject_NEW(CdbObject, &CdbType);
  if (self == NULL) return NULL;

  self->c.map = 0; /* break encapsulation -- cdb struct init'd to zero */
  cdb_init(&self->c, fd);

  self->iter_pos   = 2048;
  self->each_pos   = 2048;
  self->numrecords = 0;
  self->eod        = 0;
  self->getkey     = NULL;

  return (PyObject *) self;
}
Esempio n. 16
0
VALUE mCDB_Reader_each_for_key(VALUE self,VALUE key) {
  struct cdb db;
  VALUE value;
  struct cdb_find find;
  StringValue(key);
  int fd = open_cdb_fd(self);
  size_t vlen;
  cdb_init(&db,fd);
  cdb_findinit(&find,&db,RSTRING_PTR(key),RSTRING_LEN(key));
  while(cdb_findnext(&find) > 0) {
    vlen = cdb_datalen(&db);
    value = rb_str_buf_new(vlen);
    cdb_read(&db,RSTRING_PTR(value),vlen,cdb_datapos(&db));
    rb_str_set_len(value,vlen);
    rb_yield(value);
  }
  close(fd);
  return Qnil;
}
Esempio n. 17
0
/* LEVEL 0 - FILE */
int cdbb_open_read(struct cdbb *a, const char *f)
{
	int fd = open_read(f);
	if (fd < 0)
		return fd;

	a->r = malloc(sizeof(struct cdb));

	if (a->r == NULL) {
		close(fd);
		return -1;
	}
	/* suppress valgrind warning:
	 * "Uninitialised value was created by a heap allocation" in cdb_free */
	a->r->map = 0;

	cdb_init(a->r, fd);
	return fd;
}
Esempio n. 18
0
main(int argc,char **argv)
{
  char *key;
  int r;
  uint32 pos;
  uint32 len;
  unsigned long u = 0;

  if (!*argv) die_usage();

  if (!*++argv) die_usage();
  key = *argv;

  if (*++argv) {
    scan_ulong(*argv,&u);
  }

  cdb_init(&c,0);
  cdb_findstart(&c);

  for (;;) {
    r = cdb_findnext(&c,key,str_len(key));
    if (r == -1) die_read();
    if (!r) _exit(100);
    if (!u) break;
    --u;
  }

  pos = cdb_datapos(&c);
  len = cdb_datalen(&c);

  while (len > 0) {
    r = sizeof buf;
    if (r > len) r = len;
    if (cdb_read(&c,buf,r,pos) == -1) die_read();
    if (buffer_put(buffer_1small,buf,r) == -1) die_write();
    pos += r;
    len -= r;
  }
  if (buffer_flush(buffer_1small) == -1) die_write();
  _exit(0);
}
Esempio n. 19
0
int checks(char *key, char *buf)
{
    struct cdb cdb;
    struct cdb_find cdbf;
    int fd;
    char *data;
    unsigned keylen = strlen(key), datalen, vpos;

    if (((fd = open(DB, O_RDONLY)) == -1) ||
            (cdb_init(&cdb, fd) != 0)) {
        printf("Can't open database: %s\n", strerror(errno));
        return (-1);
    }


    if (cdb_findinit(&cdbf, &cdb, key, keylen) <= 0) {
        return (-1);
    }

    while (cdb_findnext(&cdbf) > 0) {
        char *pattern, *subject;
        int m;

        vpos = cdb_datapos(&cdb);
        datalen = cdb_datalen(&cdb);
        data = malloc(datalen + 1);
        cdb_read(&cdb, data, datalen, vpos);
        data[datalen] = '\0';

        pattern = data;
        subject = buf;
        m = match(pattern, subject);
        printf("*** match %s  ", m ? "TRUE " : "false");
        printf("%s\n", data);

        free(data);
    }

    cdb_free(&cdb);
    close(fd);
    return (0);
}
Esempio n. 20
0
int find_client_loc(char loc[2],const char ip[16])
{
  int r, fd;
  char key[32+3];
  static struct cdb c;

  fd = open_read("data.cdb");
  if (fd == -1) return 0;
  cdb_init(&c,fd);

  byte_zero(loc,2);
  key[0] = 0;
  key[1] = '%';
  if (byte_equal(ip,12,V4mappedprefix)) {
    key[2] = 'f';
    byte_copy(key + 3,4,ip+12);
    r = cdb_find(&c,key,7);
    if (!r) r = cdb_find(&c,key,6);
    if (!r) r = cdb_find(&c,key,5);
    if (!r) r = cdb_find(&c,key,4);
    if (!r) r = cdb_find(&c,key,3);
    if (r == -1) return 0;
    if (r && (cdb_datalen(&c) == 2))
      if (cdb_read(&c,loc,2,cdb_datapos(&c)) == -1) return 0;
  } else {
    unsigned int n;
    key[2] = 's';
    ip6_fmt_flat(key+3,ip);
    for (n=19; n>3; --n) {
      r = cdb_find(&c,key,n);
      if (r) break;
    }
    if (r == -1) return 0;
    if (r && (cdb_datalen(&c) == 2))
      if (cdb_read(&c,loc,2,cdb_datapos(&c)) == -1) return 0;
  }

  cdb_free(&c);
  close(fd);
  return r;
}
Esempio n. 21
0
int respond(char *q,char qtype[2],char ip[4])
{
  static struct tai cdb_valid = { 0 };
  static int fd = -1;
  struct tai one_second;
  int r;
  char key[6];

  tai_now(&now);

  if (tai_less(&cdb_valid, &now)) {
    if (fd != -1) {
      cdb_free(&c);
      close(fd);
    }
    fd = open_read("data.cdb");
    if (fd == -1) return 0;
    cdb_init(&c,fd);
    tai_uint(&one_second, 1);
    tai_add(&cdb_valid, &now, &one_second);
  }
  byte_zero(clientloc,2);
  key[0] = 0;
  key[1] = '%';
  byte_copy(key + 2,4,ip);
  r = cdb_find(&c,key,6);
  if (!r) 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;
  if (r && (cdb_datalen(&c) == 2))
    if (cdb_read(&c,clientloc,2,cdb_datapos(&c)) == -1) return 0;

  r = doit(q,qtype);

  return r;
}
Esempio n. 22
0
static Dictionary *
open_dictionary(char *path)
{
  Dictionary *dic;

  if ((dic = calloc(1, sizeof(Dictionary))) == NULL) {
    err_message_fnc("No enough memory.\n");
    return NULL;
  }

  if ((dic->path = strdup(path)) == NULL)
    return NULL;

  if ((dic->fd = open(path, O_RDONLY)) == -1) {
    perror(PROGNAME ": open");
    return NULL;
  }

  cdb_init(&dic->cdb, dic->fd);
  pthread_mutex_init(&dic->mutex, NULL);

  return dic;
}
Esempio n. 23
0
static my_bool checkpart_init(UDF_INIT *iid, UDF_ARGS *args, char *message)
{
	struct _info *info;

	if (args->arg_count != 2) {
		strmov(message,"Need two STRING args");
		return (1);
	}

	if ((args->arg_type[0] != STRING_RESULT) ||
		(args->arg_type[1] != STRING_RESULT)) {
		strmov(message,"args must be STRING");
		return (1);
	}

	args->arg_type[0] = STRING_RESULT;
	args->arg_type[1] = STRING_RESULT;


	info = (struct _info *)malloc(sizeof(struct _info));
	info->msg = strdup("Hello JP");
	info->buf = calloc(sizeof(char), BLEN);
	info->reason = calloc(sizeof(char), BLEN);

        if (((info->fd = open(DB, O_RDONLY)) == -1) ||
			(cdb_init(&info->cdb, info->fd) != 0)) {
		fprintf(stderr, "Can't open CDB database at %s: %s\n", DB, strerror(errno));
		return (1);
	}

	iid->ptr = (char *)info;
	iid->max_length = BLEN;
	iid->maybe_null = 0;
	iid->const_item = 0;

	return 0;
}
Esempio n. 24
0
static void load_rcpthosts(void)
{
  char* rh = read_file(0, "rcpthosts");
  if (!dict_init(&rcpthosts)) oom();
  if (rh) {
    const char* curr = rh;
    while (*curr) {
      const char* end;
      const char* next;
      if ((end = strchr(curr, '\n')) != 0)
	next = end + 1;
      else
	next = end = curr + strlen(curr);
      if (*curr != '#') {
	if (!str_copyb(&strbuf, curr, end-curr)) oom();
	if (!dict_add(&rcpthosts, &strbuf, 0)) oom();
      }
      curr = next;
    }
    free(rh);
  }
  if ((morercpthosts_fd = open_file(0, "morercpthosts.cdb")) != -1)
    cdb_init(&morercpthosts, morercpthosts_fd);
}
Esempio n. 25
0
SDB_API bool sdb_disk_finish (Sdb* s) {
	int reopen = 0, ret = true;
	IFRET (!cdb_make_finish (&s->m));
#if USE_MMAN
	IFRET (fsync (s->fdump));
#endif
	IFRET (close (s->fdump));
	s->fdump = -1;
	// close current fd to avoid sharing violations
	if (s->fd != -1) {
		close (s->fd);
		s->fd = -1;
		reopen = 1;
	}
#if __SDB_WINDOWS__
	if (MoveFileEx (s->ndump, s->dir, MOVEFILE_REPLACE_EXISTING)) {
		//eprintf ("Error 0x%02x\n", GetLastError ());
	}
#else
	if (s->ndump && s->dir) {
		IFRET (rename (s->ndump, s->dir));
	}
#endif
	free (s->ndump);
	s->ndump = NULL;
	// reopen if was open before
	reopen = 1; // always reopen if possible
	if (reopen) {
		int rr = sdb_open (s, s->dir);
		if (ret && rr < 0) {
			ret = false;
		}
		cdb_init (&s->db, s->fd);
	}
	return ret;
}
Esempio n. 26
0
/// Initializes shopping data structures.
void
shop_init(void)
{
    CCS rmap;
    int fd;

    // Convenience.
    if (vb_bitmatch(VB_SHOP)) {
	vb_addbit(VB_WHY);
    }

    // Open the roadmap file, and initialize the CDB infrastructure.
    if ((rmap = prop_get_str(P_ROADMAPFILE))) {
	fd = open64(rmap, O_RDONLY, 0);
	if (fd == -1) {
	    putil_syserr(0, rmap);
	} else {
	    struct stat64 stbuf;

	    // Optimization: if the roadmap is zero-length, remove it
	    // now and turn off shopping completely.
	    if (fstat64(fd, &stbuf)) {
		putil_syserr(2, rmap);
	    }
	    if (stbuf.st_size > 0) {
		ShopCDB = (struct cdb *)putil_malloc(sizeof(*ShopCDB));
		cdb_init(ShopCDB, fd);
		close(fd);
	    } else {
		close(fd);
		vb_printf(VB_SHOP, "NO ROADMAP, NO SHOPPING", rmap);
		shop_fini();
	    }
	}
    }
}
Esempio n. 27
0
void
doaxfr (char id[2])
{
    int r = 0;
    char num[4];
    char key[512];
    uint32 klen = 0;
    uint32 eod = 0, pos = 0;

    axfrcheck (zone);

    tai_now (&now);
    cdb_init (&c, fdcdb);

    byte_zero (clientloc, 2);
    key[0] = 0;
    key[1] = '%';
    byte_copy (key + 2, 4, ip);
    r = cdb_find (&c, key, 6);

    if (!r)
        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)
        errx (-1, "could not read from file `data.cdb'");
    if (r && (cdb_datalen (&c) == 2))
        if (cdb_read (&c, clientloc, 2, cdb_datapos (&c)) == -1)
            err (-1, "could not read from file `data.cdb'");

    cdb_findstart (&c);
    for (;;)
    {
        r = cdb_findnext (&c, zone, zonelen);
        if (r == -1)
            errx (-1, "could not read from file `data.cdb'");
        if (!r)
            errx (-1, "could not find information in `data.cdb'");
        dlen = cdb_datalen (&c);
        if (dlen > sizeof data)
            errx (-1, "could not read from file `data.cdb': format error");
        if (cdb_read (&c, data, dlen, cdb_datapos (&c)) == -1)
            errx (-1, "could not read from file `data.cdb': format error");
        if (build (&soa, zone, 1, id))
            break;
    }

    cdb_free (&c);
    print (soa.s, soa.len);

    seek_begin (fdcdb);
    buffer_init (&bcdb, buffer_unixread, fdcdb, bcdbspace, sizeof (bcdbspace));

    pos = 0;
    get (num, 4);
    pos += 4;
    uint32_unpack (num, &eod);
    while (pos < 2048)
    {
        get (num, 4);
        pos += 4;
    }

    while (pos < eod)
    {
        if (eod - pos < 8)
            errx (-1, "could not read from file `data.cdb': format error");
        get (num, 4);
        pos += 4;
        uint32_unpack (num, &klen);
        get (num,4);
        pos += 4;
        uint32_unpack (num, &dlen);
        if (eod - pos < klen)
            errx (-1, "could not read from file `data.cdb': format error");
        pos += klen;
        if (eod - pos < dlen)
            errx (-1, "could not read from file `data.cdb': format error");
        pos += dlen;

        if (klen > sizeof key)
            errx (-1, "could not read from file `data.cdb': format error");
        get (key, klen);
        if (dlen > sizeof data)
            errx (-1, "could not read from file `data.cdb': format error");
        get (data, dlen);

        if ((klen > 1) && (key[0] == 0))
            continue; /* location */
        if (klen < 1)
            errx (-1, "could not read from file `data.cdb': format error");
        if (dns_packet_getname (key, klen, 0, &q) != klen)
            errx (-1, "could not read from file `data.cdb': format error");
        if (!dns_domain_suffix (q, zone))
            continue;
        if (!build (&message, q, 0, id))
            continue;
        print (message.s, message.len);
    }

    print (soa.s, soa.len);
}
int
chdir_long (char *dir)
{
  int e = chdir (dir);
  if (e == 0 || errno != ENAMETOOLONG)
    return e;

  {
    size_t len = strlen (dir);
    char *dir_end = dir + len;
    struct cd_buf cdb;
    size_t n_leading_slash;

    cdb_init (&cdb);

    /* If DIR is the empty string, then the chdir above
       must have failed and set errno to ENOENT.  */
    assert (0 < len);
    assert (PATH_MAX <= len);

    /* Count leading slashes.  */
    n_leading_slash = strspn (dir, "/");

    /* Handle any leading slashes as well as any name that matches
       the regular expression, m!^//hostname[/]*! .  Handling this
       prefix separately usually results in a single additional
       cdb_advance_fd call, but it's worthwhile, since it makes the
       code in the following loop cleaner.  */
    if (n_leading_slash == 2)
      {
	int err;
	/* Find next slash.
	   We already know that dir[2] is neither a slash nor '\0'.  */
	char *slash = memchr (dir + 3, '/', dir_end - (dir + 3));
	if (slash == NULL)
	  {
	    errno = ENAMETOOLONG;
	    return -1;
	  }
	*slash = '\0';
	err = cdb_advance_fd (&cdb, dir);
	*slash = '/';
	if (err != 0)
	  goto Fail;
	dir = find_non_slash (slash + 1);
      }
    else if (n_leading_slash)
      {
	if (cdb_advance_fd (&cdb, "/") != 0)
	  goto Fail;
	dir += n_leading_slash;
      }

    assert (*dir != '/');
    assert (dir <= dir_end);

    while (PATH_MAX <= dir_end - dir)
      {
	int err;
	/* Find a slash that is PATH_MAX or fewer bytes away from dir.
	   I.e. see if there is a slash that will give us a name of
	   length PATH_MAX-1 or less.  */
	char *slash = memrchr (dir, '/', PATH_MAX);
	if (slash == NULL)
	  {
	    errno = ENAMETOOLONG;
	    return -1;
	  }

	*slash = '\0';
	assert (slash - dir < PATH_MAX);
	err = cdb_advance_fd (&cdb, dir);
	*slash = '/';
	if (err != 0)
	  goto Fail;

	dir = find_non_slash (slash + 1);
      }

    if (dir < dir_end)
      {
	if (cdb_advance_fd (&cdb, dir) != 0)
	  goto Fail;
      }

    if (cdb_fchdir (&cdb) != 0)
      goto Fail;

    cdb_free (&cdb);
    return 0;

   Fail:
    {
      int saved_errno = errno;
      cdb_free (&cdb);
      errno = saved_errno;
      return -1;
    }
  }
}
Esempio n. 29
0
/* main program */
int main(int argc, char *argv[]) {
  char combuf[BUFSIZE], data[DATASIZE];
  char *pbuf, *key, *p;
  struct cdb diccdb;
  int dicfd, ex, length;
  unsigned int keylen, datalen;

  /* open dictionary cdb file */
  if ((dicfd = open(JISYO_FILE, O_RDONLY, S_IRUSR)) < 0) {
    exit(EX_CONFIG);
  }
  /* init cdb */
  cdb_init(&diccdb, dicfd);
  /* To exit, set ex to non-zero */
  ex = 0;
  /* command loop */
  while (!ex) {
    /* Read from stdin */
    length = read(STDIN, &combuf[0], BUFSIZE - 1);
    if (length < 0) {
      exit(EX_NOINPUT);
    } else if (length == 0) {
      /* EOF detected */
      /* exit from the while loop */
      ex = 1;
      break;
    }
    /* parse request code */
    switch (combuf[0]) {
    case CLIENT_END:
      /* End of conversion requested*/
      /* exit from the while loop */
      ex = 1;
      break;
    case CLIENT_VERSION:
      if (write(STDOUT, VERSION, sizeof(VERSION) - 1) < 0) {
        exit(EX_IOERR);
      }
      break;
    case CLIENT_HOST:
      if (write(STDOUT, DUMMYHOSTNAME, sizeof(DUMMYHOSTNAME) - 1) < 0) {
        exit(EX_IOERR);
      }
      break;
    case CLIENT_REQUEST:
      /* get size of key */
      key = &combuf[1];
      for (pbuf = &combuf[1]; *pbuf != ' ' && pbuf != &combuf[length - 1];
           pbuf++) {
      }
      keylen = pbuf - &combuf[1];
      if (keylen <= 0) { /* invalid keysize */
        exit(EX_PROTOCOL);
      }
      /* lookup the cdb database */
      switch (cdb_find(&diccdb, key, keylen)) {
      case -1: /* fatal error on cdb_find() */
        exit(EX_SOFTWARE);
        break;
      case 1: /* found */
        if ((datalen = cdb_datalen(&diccdb)) >= DATASIZE - 2) {
          exit(EX_PROTOCOL);
        }
        /* generate the answer string */
        p = data;
        *p++ = SERVER_FOUND;
        if (cdb_read(&diccdb, p, datalen, cdb_datapos(&diccdb)) < 0) {
          exit(EX_SOFTWARE);
        }
        p += datalen;
        *p = '\n';
        /* sending found code and the result data string with LF */
        if (write(STDOUT, data, datalen + 2) < 0) {
          exit(EX_IOERR);
        }
        break;
      case 0: /* NOT found */
        /* generate the answer string */
        combuf[0] = SERVER_NOT_FOUND;
        *pbuf = '\n';
        /* sending error code and the key string with LF */
        /* this action is required by skkinput */
        if (write(STDOUT, combuf, keylen + 2) < 0) {
          exit(EX_IOERR);
        }
        break;
      default: /* unknown cdb return value */
        exit(EX_SOFTWARE);
        break;
      }
      break;
    /* end CLIENT_REQUEST switch clause */
    /* unknown request code */
    default:
      exit(EX_PROTOCOL);
    }
    /* end request code parsing */
  }
  /* end while loop */
  /* close dictionary db file */
  cdb_free(&diccdb);
  if (close(dicfd) != 0) {
    exit(EX_IOERR);
  }
  /* normal exit, finally */
  exit(EX_OK);
}
Esempio n. 30
0
/* initialize XMAP */
XMAP *xmap_init(char *basedir)
{
    char path[XM_PATH_MAX];
    struct stat st = {0};
    XMAP *xmap = NULL;
    int i = 0, k = 0, v = 0;
    unsigned int id  = 0;

    if(basedir && (xmap = (XMAP *)xmm_mnew(sizeof(XMAP))))
    {
        //xmap->mtrie = mtrie_init();
        MUTEX_INIT(xmap->mutex);
        /* logger */
        sprintf(path, "%s/%s", basedir, "xmap.log");
        xmap_mkdir(path);
        LOGGER_INIT(xmap->logger, path);
        /* tree */
        sprintf(path, "%s/%s", basedir, "xmap.tree");
        xmap->tree = mmtree_init(path);
        sprintf(path, "%s/%s", basedir, "xmap.tree64");
        xmap->tree64 = mmtree64_init(path);
        /* kmap */
        sprintf(path, "%s/%s", basedir, "xmap.kmap");
        xmap->kmap = mmtrie_init(path);
        /* queue */
        sprintf(path, "%s/%s", basedir, "xmap.queue");
        xmap->queue = mmqueue_init(path);
        /* db */
        sprintf(path, "%s/%s", basedir, "cache/");
        xmap->db = cdb_init(path, CDB_USE_MMAP);
        /* state */
        sprintf(path, "%s/%s", basedir, "xmap.state");
        if((xmap->stateio.fd = open(path, O_CREAT|O_RDWR, 0644)) > 0
                && fstat(xmap->stateio.fd, &st) == 0)
        {
            if((xmap->stateio.map = mmap(NULL, sizeof(XMSTATE), PROT_READ|PROT_WRITE,
                                         MAP_SHARED, xmap->stateio.fd, 0)) == NULL
                    || xmap->stateio.map == (void *)-1)
            {
                FATAL_LOGGER(xmap->logger, "mmap state:%s failed, %s", path, strerror(errno));
                _exit(-1);
            }
            xmap->state = (XMSTATE *)(xmap->stateio.map);
            xmap->stateio.end = st.st_size;
            if(st.st_size == 0)
            {
                xmap->stateio.end = xmap->stateio.size = sizeof(XMSTATE);
                if(ftruncate(xmap->stateio.fd, xmap->stateio.end) != 0)
                {
                    FATAL_LOGGER(xmap->logger, "ftruncate state %s failed, %s", path, strerror(errno));
                    _exit(-1);
                }
                memset(xmap->state, 0, sizeof(XMSTATE));
            }
            for(i = 0; i < DBASE_MASK_MAX; i++)
            {
                if(xmap->state->masks[i].root == 0)
                    xmap->state->masks[i].root = mmtree64_new_tree(xmap->tree64);
            }
        }
        /* disk */
        sprintf(path, "%s/%s", basedir, "xmap.disk");
        if((xmap->diskio.fd = open(path, O_CREAT|O_RDWR, 0644)) > 0
                && fstat(xmap->diskio.fd, &st) == 0)
        {
            if((xmap->diskio.map = mmap(NULL, sizeof(MDISK) * XM_DISK_MAX, PROT_READ|PROT_WRITE,
                                        MAP_SHARED, xmap->diskio.fd, 0)) == NULL
                    || xmap->diskio.map == (void *)-1)
            {
                FATAL_LOGGER(xmap->logger, "mmap disk:%s failed, %s", path, strerror(errno));
                _exit(-1);
            }
            xmap->disks = (MDISK *)(xmap->diskio.map);
            xmap->diskio.end = st.st_size;
        }
        /* meta */
        sprintf(path, "%s/%s", basedir, "xmap.meta");
        if((xmap->metaio.fd = open(path, O_CREAT|O_RDWR, 0644)) > 0
                && fstat(xmap->metaio.fd, &st) == 0)
        {
            if((xmap->metaio.map = mmap(NULL, sizeof(XMMETA) * XM_META_MAX, PROT_READ|PROT_WRITE,
                                        MAP_SHARED, xmap->metaio.fd, 0)) == NULL
                    || xmap->metaio.map == (void *)-1)
            {
                FATAL_LOGGER(xmap->logger, "mmap meta:%s failed, %s", path, strerror(errno));
                _exit(-1);
            }
            xmap->metas = (XMMETA *)(xmap->metaio.map);
            xmap->metaio.end = st.st_size;
            xmap->start_time = time(NULL);
        }
        if(!xmap->state->qwait) xmap->state->qwait = mmtree_new_tree(xmap->tree);
        if(!xmap->state->qleft) xmap->state->qleft = mmqueue_new(xmap->queue);
        xmap->state->id_wait = 0;
        while((id = mmtree_min(xmap->tree, xmap->state->qwait, &k, &v)))
        {
            mmtree_remove(xmap->tree, xmap->state->qwait, id, NULL, NULL);
        }
        while(mmqueue_pop(xmap->queue, xmap->state->qleft, (int *)&id) > 0);
    }
    return xmap;
}