Пример #1
0
int create_shmfile(const char *name,int oflags,mode_t mode){
	int fd;

	if(name[0] != '/'){
		bitch("Not an absolute path: %s\n",name);
		return -1;
	}
#ifdef LIB_COMPAT_FREEBSD
	// FreeBSD sets certain file descriptor flags based on shm_open(3), so
	// we need to use it (Linux's just places things on the tmpfs)
	fd = Shm_open(name,oflags,mode);
#else
#ifdef LIB_COMPAT_LINUX
	// We don't want to use shm_open(3) on Linux, because it restricts us
	// to our IPC namespace's tmpfs (/dev/shm by default), meaning we
	// (a) collide with other processes and (b) can't use hugetlbfs. Thus,
	// we use open(2) directly, but enforce a VM-based filesystem.
	// FIXME enforce filesystem restrictions on Linux
	fd = OpenCreat(name,oflags,mode);
#else
	bitch("No support for %s, %x, %x on this OS\n",name,oflags,mode);
	fd = -1;
#endif
#endif
	return fd;
}
Пример #2
0
Файл: soa.c Проект: jelu/validns
static struct rr* soa_parse(char *name, long ttl, int type, char *s)
{
    struct rr_soa *rr = getmem(sizeof(*rr));
    long long i;

    rr->mname = extract_name(&s, "mname", 0);
    if (!rr->mname) return NULL;
    rr->rname = extract_name(&s, "rname", 0);
    if (!rr->rname) return NULL;
    i = extract_integer(&s, "serial", NULL);
    if (i < 0) return NULL;
    if (i > 4294967295UL) return bitch("serial is out of range");
    rr->serial = i;
    rr->refresh = extract_timevalue(&s, "refresh");
    if (rr->refresh < 0) return NULL;
    rr->retry = extract_timevalue(&s, "retry");
    if (rr->retry < 0) return NULL;
    rr->expire = extract_timevalue(&s, "expire");
    if (rr->expire < 0) return NULL;
    rr->minimum = extract_timevalue(&s, "minimum");
    if (rr->minimum < 0) return NULL;
    if (ttl < 0 && G.opt.soa_minttl_as_default_ttl) {
        ttl = rr->minimum;
    }
    if (*s) {
        return bitch("garbage after valid SOA data");
    }
    return store_record(type, name, ttl, rr);
}
Пример #3
0
// Allocate a percentage of available memory for the object listed.  Totally
// non-exact. The percentage p must satisfy 0 < p <= 100. Initializes returned
// memory to 0.
void *Palloc(const char *name,size_t osiz,unsigned *num,unsigned p){
	void *ret = NULL;
	size_t rsiz;

	if(p <= 0 || p > 100){
		bitch("Invalid allocation %u%% for %s\n",p,name);
		return NULL;
	}
	pthread_mutex_lock(&memlock);
	++allocs_reqd;
	if((rsiz = size_palloc_req(p,name)) < osiz){
		++allocs_fail;
	}else{
		rsiz -= rsiz % osiz;
		if((ret = malloc(rsiz)) == NULL){
			++allocs_fail;
		}else{
			++allocs_used;
		}
	}
	pthread_mutex_unlock(&memlock);
	if(ret == NULL){
		bitch("%%-alloc failed for %zu bytes for %s\n",rsiz,name);
	}else{
		*num = rsiz / osiz;
		nag("%s: %zu(%p) ok\n",name,rsiz,ret);
		nag("%u%% -> %zub (%u %zub %s)\n",p,rsiz,*num,osiz,name);
	}
	return ret;
}
Пример #4
0
// Provide the maximum memory size in bytes. It will be checked against free
// memory (*not* claimed memory; we do not know other reservations), and capped
// at 50% thereof. If the limit is far too low for a sane app, this will also
// result in a -1 return (mainly to catch mistakes involving units). A limit
// of 0 implies capping only wrt known free memory.
int limit_memory(size_t s){
	int ret = 0;

	if(memory_usage_limit){
		bitch("Not resetting memlimit of %jub\n",memory_usage_limit);
		return -1;
	}
	if(s){
		nag("Provided a memory limit of %zub\n",s);
	}else{
		s = DEFAULT_APP_MEMLIMIT;
	}
	memory_usage_limit = determine_sysmem();
	static_usage = determine_static_usage();
	nag("Preexisting allocation total: %zu\n",static_usage);
	s += static_usage;
	if(s > memory_usage_limit){
		bitch("Capping %zub to syslimit %jub\n",s,memory_usage_limit);
		ret = -1;
	}else if(s){
		struct rlimit rl = { .rlim_cur = s, .rlim_max = s, };

		ret |= Setrlimit(RLIMIT_AS,&rl);
		memory_usage_limit = s;
	}
	nag("Setting memlimit: %ju MiB\n",memory_usage_limit / MIBIBYTE);
	return ret;
}
Пример #5
0
int parser_byline(int fd,line_parser_cb lcb,void *arg){
	int ret = -1,lines = 0;
	line_parser_ctx ctx;
	char *line;

	if(prepare_line_parser(&ctx,fd)){
		return -1;
	}
	if(!lcb){
		nag("Not executing any parser callbacks\n");
	}
	errno = 0;
	while( (line = line_parser_next(&ctx)) ){
		++lines;
		if(lcb && lcb(line,arg)){
			bitch("Failure in parse function, exiting\n");
			goto done;
		}
		errno = 0;
	}
	if(errno){
		bitch("Failure reading data for parsing at line %d\n",lines);
	}else{
		nag("Read %d lines\n",lines);
		ret = 0;
	}

done:
	destroy_line_parser(&ctx);
	return ret;
}
Пример #6
0
// FIXME we need better EV_ERROR handling
static inline void
handle_kqueue_results(poller *p,const struct kevent *kevents,unsigned events){
	unsigned n = 0;

	// nag("Handling %u events\n",events);
	for(n = 0 ; n < events ; ++n){
		const struct kevent *kv = &kevents[n];

		if(kv->filter == EVFILT_SIGNAL){
			nag("SignalRX (%s)\n",strsignal(kv->ident));
			if(kv->ident == SIGCHLD){
				p->sigchldrx += kv->data;
				handle_sigchld(p);
			}
		}else{
			pollfd_state *state;
			int fd = kv->ident;

			if(fd < 0 || fd >= p->pfds_available){
				bitch("Invalid fd %d (max %d)\n",fd,p->pfds_available);
				inc_stateexceptions();
				continue;
			}
			state = &p->fdstates[fd];
			if(fd != state->pfd.fd){
				// We might close a descriptor despite
				// outstanding events later in the vector. Note
				// them, but don't take action otherwise.
				handle_invalidated_kevent(kv,fd,state);
			}else{
				struct timeval tvstart,tvend;
				int r;

				Gettimeofday(&tvstart,NULL);
				state->lastuse_time = tvstart.tv_sec;
				if(kv->flags & EV_ERROR){
					handle_kqueue_error(state);
					r = -1;
				}else if(kv->filter == EVFILT_READ){
					r = handle_kqueue_read(p,state);
				}else if(kv->filter == EVFILT_WRITE){
					r = handle_kqueue_write(p,state);
				}else if(kv->filter == EVFILT_TIMER){
					// nag("Timer callback %d\n",fd);
					r = handle_kqueue_timeout(p,state);
				}else{
					bitch("Unknown kevent filter %d\n",kv->filter);
					inc_stateexceptions();
					r = 0;
				}
				if(!r){
					time_avgmax(&state->pfd_avgmax_time,&tvend,&tvstart);
				}else{
					purge_fd_resulthandler(p,state,fd);
				}
			}
		}
	}
}
Пример #7
0
static struct rr *naptr_parse(char *name, long ttl, int type, char *s)
{
	struct rr_naptr *rr = getmem(sizeof(*rr));
	int i;
	struct binary_data text;

	i = extract_integer(&s, "order");
	if (i < 0)
		return NULL;
	if (i >= 65536)
		return bitch("order range is not valid");
	rr->order = i;

	i = extract_integer(&s, "preference");
	if (i < 0)
		return NULL;
	if (i >= 65536)
		return bitch("preference range is not valid");
	rr->preference = i;

	text = extract_text(&s, "flags");
	if (text.length < 0)
		return NULL;
	for (i = 0; i < text.length; i++) {
		if (!isalnum(text.data[i])) {
			return bitch("flags contains illegal characters");
		}
	}
	rr->flags = text;

	text = extract_text(&s, "services");
	if (text.length < 0)
		return NULL;
	rr->services = text;

	text = extract_text(&s, "regexp");
	if (text.length < 0)
		return NULL;
	rr->regexp = text;

	rr->replacement = extract_name(&s, "replacement");
	if (!rr->replacement)
		return NULL;

	if (*s) {
		return bitch("garbage after valid NAPTR data");
	}

	return store_record(type, name, ttl, rr);
}
Пример #8
0
static int
drop_privs_r(const char *username,const char *groupname,size_t buflen){
	struct passwd pwent,*pdb = NULL;
	struct group grent,*grp = NULL;
	uid_t uid,olduid = getuid();
	gid_t gid,oldgid = getgid();
	char buf[buflen];

	if(groupname){
		if(getgrnam_r(groupname,&grent,buf,sizeof(buf),&grp) || !grp){
			moan("Couldn't look up group %s\n",groupname);
			return -1;
		}
		gid = grp->gr_gid;
		if(setgid(gid)){
			moan("Couldn't setgid to group %d\n",gid);
			return -1;
		}
		if(getgid() != gid){
			bitch("getgid() returned %d, not %d\n",getgid(),gid);
			return -1;
		}
		if(getegid() != gid){
			bitch("getegid() returned %d, not %d\n",getegid(),gid);
			return -1;
		}
		nag("Dropped permissions to group %s (GID %d) from GID %d\n",groupname,gid,oldgid);
	}
	if(username){
		if(getpwnam_r(username,&pwent,buf,sizeof(buf),&pdb) || !pdb){
			moan("Couldn't look up username %s\n",username);
			return -1;
		}
		uid = pdb->pw_uid;
		if(setuid(uid)){
			moan("Couldn't setuid to user %d\n",uid);
			return -1;
		}
		if(getuid() != uid){
			bitch("getuid() returned %d, not %d\n",getuid(),uid);
			return -1;
		}
		if(geteuid() != uid){
			bitch("geteuid() returned %d, not %d\n",geteuid(),uid);
			return -1;
		}
		nag("Dropped permissions to user %s (UID %d) from UID %d\n",username,uid,olduid);
	}
	return 0;
}
Пример #9
0
static int extract_certificate_type(char **s, char *what)
{
	int type;
	char *str_type;

	if (isdigit(**s)) {
		type = extract_integer(s, what);
		if (type >= 1 && type <= 8)
			return type;
		if (type == 253 || type == 254)
			return type;
		if (type >= 65280 && type <= 65534)
			return type;
		if (type < 0 || type > 65535) {
			bitch("bad certificate type %d", type);
			return -1;
		}
		if (type == 0 || type == 255 || type == 65535) {
			bitch("certificate type %d is reserved by IANA", type);
			return -1;
		}
		bitch("certificate type %d is unassigned", type);
		return -1;
	} else {
		str_type = extract_label(s, what, "temporary");
		if (!str_type) return -1;
		if (strcmp(str_type, "pkix") == 0)
			return 1;
		if (strcmp(str_type, "spki") == 0)
			return 2;
		if (strcmp(str_type, "pgp") == 0)
			return 3;
		if (strcmp(str_type, "ipkix") == 0)
			return 4;
		if (strcmp(str_type, "ispki") == 0)
			return 5;
		if (strcmp(str_type, "ipgp") == 0)
			return 6;
		if (strcmp(str_type, "acpkix") == 0)
			return 7;
		if (strcmp(str_type, "iacpkix") == 0)
			return 8;
		if (strcmp(str_type, "uri") == 0)
			return 253;
		if (strcmp(str_type, "oid") == 0)
			return 254;
		bitch("bad certificate type %s", str_type);
		return -1;
	}
}
Пример #10
0
static int
antimalware_rewrite(icap_state *is,unsigned probability,const char *name){
#define HDRTAG "X-LOG-amww: "
	char hdr[strlen(HDRTAG) + SCANMAPI_MAX_STRLEN] = HDRTAG;
	unsigned int eid = 0, pid = 0, uid = 0, gid = 0;
	SiteInfoType si = SITEINFOTYPE_INITIALIZER;

	inc_maldetect();
	nag("Rewriting based off probability %u name %s\n",probability,name);
	strcpy(hdr + strlen(HDRTAG),name);
	if(add_icap_respheader(is,hdr)){
		return -1;
	}

	if(is->encaps.http.x_sweb_data) {
	  if(extract_reqmod_data(is->encaps.http.x_sweb_data, &si, &eid, &pid, &uid, &gid)) {
	    nag("Error extracting reqmod data\n");
	    return reqresp_error_msg(is, "Malware detected, but unable to parse policy data\n");
	  }
	} else {
	  bitch("No data header\n");
	}

	if(!pid) {
	  return reqresp_error_msg(is, "Malware detected, but no policy data available\n");
	}
	
	return reqresp_blocked(is, ec_get_block_page(ec, pid), is->encaps.http.rawuri, &si, name);
#undef HDRTAG
}
Пример #11
0
static int
lex_uint_ashex(const unsigned char **buf,uintmax_t *val,unsigned bits){
	const unsigned char *start = *buf,*numstart;
	uintmax_t v = 0;
	int ret = 1;

	// nag("Looking for %u hex bits in %s\n",bits,*buf);
	skip_whitespace(buf);
	numstart = *buf;
	while(isxdigit(**buf)){
		if((ret = safely_add_hex(bits,&v,**buf))){
			goto err;
		}
		++*buf;
	}
	if(numstart == *buf){
		goto err;
	}
	*val = v;
	// nag("Wanted %u-bit uint, got [%llu]\n",bits,*val);
	return 0;

err:
	bitch("Wanted %u-bit uint, got [%s]\n",bits,start);
	*buf = start;
	return ret;
}
Пример #12
0
static int
pollinbuf_blob_cb(struct pollfd_state *pfd){
	pollinbuf *pibuf = get_pfd_icap(pfd)->pibuf;
	typeof(pibuf->modestate.chunkdata) *chunk;
	blob_read_res res;
	uint32_t remains;

	chunk = &pibuf->modestate.chunkdata;
	remains = chunk->chunklen - chunk->chunkread;
	res = read_blob(pfd->pfd.fd,&pibuf->cr,chunk->okey,&chunk->dumpoff,&remains);
	if(res == BLOB_READ_SYSERR){
		bitch("Error while reading %ub for chunk\n",remains);
		return -1;
	}
	chunk->chunkread += chunk->chunklen - chunk->chunkread - remains;
	if(res == BLOB_READ_NBLOCK){
		return 0;
	}
	if(chunk->cb(pfd)){
		return -1;
	}
	// For edge-triggered RX, we want to return 1 until a read() actually
	// returns -1 + EAGAIN. For level-triggered, return 0 on
	// BLOB_READ_SUCCESS. We're either that or BLOB_READ_MOREDATA.
	return 1;
}
Пример #13
0
// Lexing functions return -1 if they could not convert due to system error, 1
// if a parse error occured. Otherwise, they return 0, advance the double
// pointer, and store the result. The dpointer and result var are not molested
// if the result is invalid.
static int
lex_uint(const unsigned char **buf,uintmax_t *val,unsigned bits){
	const unsigned char *start = *buf,*numstart;
	uintmax_t v = 0;
	int ret = 1;

	// nag("Looking for %u bits in %s\n",bits,*buf);
	skip_whitespace(buf);
	numstart = *buf;
	if(*numstart == '0'){
		if(lex_uint_0helper(buf,val,bits)){
			goto err;
		}
	}else{
		while(isdigit(**buf)){
			if((ret = safely_add_dec(bits,&v,**buf))){
				goto err;
			}
			++*buf;
		}
		if(numstart == *buf){
			goto err;
		}
		*val = v;
	}
	// nag("Wanted %u-bit uint, got [%ju]\n",bits,*val);
	return 0;

err:
	bitch("Wanted %u-bit uint, got [%s]\n",bits,start);
	*buf = start;
	return ret;
}
Пример #14
0
void *hex2bin(const char *asciihex, size_t *len) {
  void *result; 
  
  *len = strlen(asciihex);
  
  if(*len % 2 || !*len) {
    bitch("Ascii hex string has invalid %zu characters\n",*len);
    return NULL;
  }
  
  *len /= 2;

  result = Malloc("bindata", *len);
  if(!result) {
    return NULL;
  }

  if(!hextoascii(asciihex, result, EOF, *len)) {
    nag("Error converting hex string\n");
    Free(result);
    return NULL;
  }

  return result;
}
Пример #15
0
int add_icap_respheader(icap_state *is,const char *hdr){
	const char *cur;
	size_t len,hlen;
	char *tmp;

	nag("Adding ICAP header: %s\n",hdr);
	for(cur = hdr ; *cur ; ++cur){
		if(*cur == 0xd || *cur == 0xa){
			bitch("Illegal character (%u) in header %s\n",*cur,hdr);
			return -1;
		}
	}
	hlen = strlen(hdr);
	len = hlen + strlen(CRLF) + 1;
	if(is->respheaders){
		len += strlen(is->respheaders);
	}
	if((tmp = Realloc("response headers",is->respheaders,len)) == NULL){
		return -1;
	}
	is->respheaders = tmp;
	memcpy(tmp + len - hlen - strlen(CRLF) - 1,hdr,hlen);
	memcpy(tmp + len - strlen(CRLF) - 1,CRLF,strlen(CRLF) + 1);
	return 0;
}
Пример #16
0
static inline void
purge_fd_resulthandler(poller *p,pollfd_state *state,int fd){
	if(state->pfd.fd != fd){
		bitch("already killed fd %d\n",fd);
		inc_stateexceptions();
		return;
	}
	nag("Purging fd %d\n",fd);
	if(state->timerfd >= 0){
		nag("timerfd set: %d\n",state->timerfd);
		// state->timerfd == fd on fbsd
		if(del_timeout_from_pollqueue(p,fd)){
			inc_stateexceptions();
		}
	}
	if(state->freefxn){
		state->freefxn(state->state);
	}
	if(Close(fd)){
		inc_stateexceptions();
	}
	--p->pfds_active;
	memset(state,0,sizeof(*state));
	state->timerfd = -1;
	state->pfd.fd = -1;
}
Пример #17
0
static int
create_kqueue(poller *p){
	if(p->pfds_available <= 0){
		bitch("Poller's pfds weren't initialized\n");
		return -1;
	}
	p->ksize = p->pfds_available;
	p->csize = 2 * p->pfds_available;
	if((p->kv = Malloc("kqueue vector",sizeof(*p->kv) * p->ksize)) == NULL){
		return -1;
	}
	if((p->cv = Malloc("kchange vector",sizeof(*p->cv) * p->csize)) == NULL){
		Free(p->kv);
		return -1;
	}
	if((p->kq = kqueue()) < 0){
		Free(p->kv);
		Free(p->cv);
		return -1;
	}
	p->kchanges = 0;
	if(enqueue_kqueue_change(p,POLLERSIGNAL,EVFILT_SIGNAL,EV_ADD,0,0,NULL)){
		destroy_kqueue(p);
		return -1;
	}
	if(enqueue_kqueue_change(p,SIGCHLD,EVFILT_SIGNAL,EV_ADD,0,0,NULL)){
		destroy_kqueue(p);
		return -1;
	}
	return 0;
}
Пример #18
0
int main(int argc, char **argv)
{
    g_fd = open(argv[1], O_RDWR);
    if (errno == ENOENT && g_fd < 0)
    {
        int i;
        for (i = 0; i < 120; i++)
        {
            g_fd = open(argv[1], O_RDWR);
            if (g_fd >= 0)
                break;
            printf("."); fflush(stdout);
            usleep(500000);
        }
        printf("\n");
    }
    if (g_fd < 0)
        return bitch("open");

//    reset();
//    set_config(0);
//    set_config(1);

    usb_set_connected(0, 1);
    claim_if(0);

#if 0
    msd();
#else
    palm();
#endif
    return 0;
}
Пример #19
0
static int
icapstartlines_bad(const char **slines){
	struct sockaddr_in sina;
	const char **cur;
	int ret = -1,sd;

	if(common_start()){
		goto done;
	}
	memset(&sina,0,sizeof(sina));
	sina.sin_port = htons(ICAP_DEFAULT_PORT);
	sina.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	sina.sin_family = AF_INET;
	for(cur = slines ; *cur ; ++cur){
		if((sd = make_tcp_socket(PF_INET)) >= 0){
			if(Connect(sd,(struct sockaddr *)&sina,sizeof(sina)) == 0){
				printf(" Sending %s",*cur);
				if((strlen(*cur) == 0 || Writen(sd,*cur,strlen(*cur)) == 0)){
					int i,v = 0;
					char c;

					while((i = read(sd,&c,sizeof(c))) == sizeof(c)){
						if(!v){
							printf("  ");
							v = 1;
						}
						putc(c,stdout);
						if(c == '\n'){
							v = 0;
						}
					}
					if(i == 0){
						if(Close(sd)){
							goto done;
						}
						continue; // mmm, spaghetti
					}else{
						if(i < 0){
							moan("Couldn't read reply on %d\n",sd);
						}else{
							bitch("Got %d reading on %d\n",i,sd);
						}
					}
				}
			}
			Close(sd);
		}
		goto done;
	}
	ret = 0;

done:
	ret |= close_icap_servers();
	ret |= reap_poller_thread(snarepoller);
	ret |= destroy_poller(snarepoller);
	ret |= stop_config();
	ret |= stop_fileconf();
	return ret;
}
Пример #20
0
static int
parse_icap_version(char **buf){
	parse_whitespaces(buf);
	if(strncasecmp(*buf,ICAP_VERSION_STR,__builtin_strlen(ICAP_VERSION_STR))){
		bitch("Bad ICAP version: %s != %s\n",*buf,ICAP_VERSION_STR);
		return -1;
	}
	*buf += __builtin_strlen(ICAP_VERSION_STR);
	return 0;
}
Пример #21
0
static int
open_procfs_file(const char *relpath){
	char path[PATH_MAX];

	if(snprintf(path,PATH_MAX,PROCMOUNT"/%s",relpath) >= PATH_MAX){
		bitch("Pathname was too long: "PROCMOUNT"/%s\n",relpath);
		return -1;
	}
	return Open(path,O_RDONLY);
}
Пример #22
0
static struct rr* cert_parse(char *name, long ttl, int type, char *s)
{
	struct rr_cert *rr = getmem(sizeof(*rr));
	int cert_type, key_tag, alg;

	cert_type = extract_certificate_type(&s, "certificate type");
	if (cert_type < 0)	return NULL;
	rr->type = cert_type;

	key_tag = extract_integer(&s, "key tag");
	if (key_tag < 0)	return NULL;
	if (key_tag > 65535)
		return bitch("bad key tag");
	rr->key_tag = key_tag;

	if (isdigit(*s)) {
		alg = extract_integer(&s, "algorithm");
		if (alg < 0)	return NULL;
		if (alg > 255)	return bitch("bad algorithm");
		if (alg != 0) {  /* 0 is just fine */
			if (algorithm_type(alg) == ALG_UNSUPPORTED)
				return bitch("bad algorithm %d", alg);
		}
	} else {
		alg = extract_algorithm(&s, "algorithm");
		if (alg == ALG_UNSUPPORTED)	return NULL;
	}
	rr->algorithm = alg;

	if (alg == 0 && key_tag != 0) {
		/* we might want to bitch here, but RFC says "SHOULD", so we don't */
	}

	rr->certificate = extract_base64_binary_data(&s, "certificate");
	if (rr->certificate.length < 0)	return NULL;
	/* TODO validate cert length based on algorithm */

	if (*s) {
		return bitch("garbage after valid CERT data");
	}
	return store_record(type, name, ttl, rr);
}
Пример #23
0
int add_signal_to_evcore(evhandler *eh,struct evectors *ev,int sig,
				evcbfxn rfxn,void *cbstate){
	if(sig >= eh->sigarraysize){
		bitch("Signal too high (%d >= %u)\n",sig,eh->sigarraysize);
		return -1;
	}
	if(add_signal_event(eh,ev,sig,rfxn,cbstate)){
		return -1;
	}
	return 0;
}
Пример #24
0
int writeq_sendfile(writeq *wq,struct oqueue_key *okey,off_t off,off_t len){
	pending_msg *pm;

	if(len < 0){
		bitch("Cannot enqueue %lldb file @%lld\n",(long long)len,(long long)off);
		return -1;
	}else if(len == 0){
		return 0;
	}else if(sizeof(len) > sizeof(size_t)){
		if(len > (typeof(len))SSIZE_MAX){
			bitch("%lld > %lld\n",(long long)len,(long long)(typeof(len))SSIZE_MAX);
			return -1;
		}
	}
	if((pm = create_pending_msg_okey(okey,off,(size_t)len)) == NULL){
		return -1;
	}
	enqueue_writer_msg(wq,pm);
	return 0;
}
Пример #25
0
// Move the map back to the beginning of the underlying object (slide it left)
int reset_mmap_window(mmap_window *mw,int fd,int prot){
	void *tmp;

	if(mw->maplen <= 0){
		bitch("Invalid arguments (%zu)\n",mw->maplen);
		return -1;
	}
	if(fd >= 0){
		tmp = Mmap(mw->mapbase,mw->maplen,prot,mmap_flags(fd) | MAP_FIXED,fd,0);
		if(tmp != mw->mapbase){
			bitch("Invalid MAP_FIXED result (%p, %p)\n",tmp,mw->mapbase);
			if(tmp != MAP_FAILED){ // FIXME verify it doesn't overlap!
				Munmap(tmp,mw->maplen);
			}
			return -1;
		}
	}
	mw->mapoff = 0;
	return 0;
}
Пример #26
0
static struct rr *afsdb_parse(char *name, long ttl, int type, char *s)
{
    struct rr_afsdb *rr = getmem(sizeof(*rr));

    rr->subtype = extract_integer(&s, "AFSDB subtype", NULL);
    if (rr->subtype < 0)
        return NULL;

    if (rr->subtype != 1 && rr->subtype != 2)
        return bitch("unknown AFSDB subtype");

    rr->hostname = extract_name(&s, "AFSDB hostname", 0);
    if (!rr->hostname)
        return NULL;

    if (*s) {
        return bitch("garbage after valid AFSDB data");
    }

    return store_record(type, name, ttl, rr);
}
Пример #27
0
char *Strdup(const char *s){
	char *ret;

	if(s == NULL){
		bitch("Can't duplicate NULL\n");
		return NULL;
	}
	if( (ret = Malloc("string copy",strlen(s) + 1)) ){
		strcpy(ret,s);
	}
	return ret;
}
Пример #28
0
static int
handle_kqueue_timeout(struct poller *p,pollfd_state *state){
	typeof(state->timeoutfxn) tout = state->timeoutfxn;
	int ret = 0;

	if(tout == NULL){
		bitch("No timeout callback for POLLOUT on %d\n",state->pfd.fd);
	}else{
		ret |= tout(p,state);
	}
	return ret;
}
Пример #29
0
Файл: a.c Проект: umq/validns
static struct rr *a_parse(char *name, long ttl, int type, char *s)
{
	struct rr_a *rr = getmem(sizeof(*rr));

	if (extract_ipv4(&s, "IPv4 address", &rr->address) <= 0)
		return NULL;
	if (*s) {
		return bitch("garbage after valid A data");
	}

	return store_record(type, name, ttl, rr);
}
Пример #30
0
// Slide the map forward over the mapped object
int slide_mmap_window(mmap_window *mw,int fd,int prot,size_t delta){
	void *tmp;

	if(delta == 0 || mw->maplen <= 0){
		bitch("Invalid arguments (%zu, %zu)\n",delta,mw->maplen);
		return -1;
	}
	// FIXME ought be using remap_file_pages(2) on Linux for performance
	tmp = Mmap(mw->mapbase,mw->maplen,prot,mmap_flags(fd) | MAP_FIXED,
					fd,mw->mapoff + delta);
	if(tmp != mw->mapbase){
		bitch("Invalid MAP_FIXED result (%p, %p)\n",tmp,mw->mapbase);
		if(tmp != MAP_FAILED){
			Munmap(tmp,mw->maplen); // FIXME unsafe
		}
		track_failloc();
		return -1;
	}
	mw->mapoff += delta;
	return 0;
}