Esempio n. 1
0
int incoming_grow_maybe(struct incoming *in)
{
	if(++in->size<in->allocated) return 0;
	// Make the incoming array bigger.
	in->allocated+=32;
//printf("grow incoming to %d\n", in->allocated);
	if((in->weak=(uint64_t *)
		realloc_w(in->weak, in->allocated*sizeof(uint64_t), __func__))
	  && (in->found=(uint8_t *)
		realloc_w(in->found, in->allocated*sizeof(uint8_t), __func__)))
			return 0;
	return -1;
}
Esempio n. 2
0
File: cvss.c Progetto: Shloub/burp
int get_vss(BFILE *bfd, struct sbuf *sb, char **vssdata, size_t *vlen,
	struct conf **confs)
{
	bsid sid;
	char *tmp=NULL;
	*vlen=0;
	while(!ensure_read(bfd, (char *)&sid, bsidsize, 0))
	{
		int64_t s=0;

		if(!(tmp=(char *)realloc_w(tmp, (*vlen)+bsidsize, __func__)))
			goto error;
		memcpy(tmp+(*vlen), &sid, bsidsize);
		(*vlen)+=bsidsize;

		// dwStreamId==1 means start of backup data, so finish.
		if(sid.dwStreamId==1)
		{
		//	logp("\n%s: %d + %d\n",
		//		path, (int)sid.Size, (int)sid.dwStreamNameSize);
			bfd->datalen=sid.Size;
			break;
		}

		// Otherwise, need to read in the rest of the VSS header.
		s=(sid.Size)+(sid.dwStreamNameSize);
		if(!(tmp=(char *)realloc_w(tmp, (*vlen)+s, __func__))
		  || ensure_read(bfd, tmp+(*vlen), s, 1))
		{
			goto error;
			return -1;
		}
		(*vlen)+=s;
	}
	if(!(*vssdata=(char *)realloc_w(*vssdata, (*vlen)+9, __func__)))
		goto error;
	snprintf(*vssdata, 9, "%c%08X", META_VSS, (unsigned int)*vlen);
	memcpy((*vssdata)+9, tmp, *vlen);
	(*vlen)+=9;
	return 0;
error:
	if(tmp) free(tmp);
	if(*vssdata)
	{
		free(*vssdata);
		*vssdata=NULL;
	}
	*vlen=0;
	return -1;
}
Esempio n. 3
0
int extract_params(char *msg, char **argv[]) {

	char *savedptr;
	int argc = 0, size = STARTING_PARAMS;

	*argv = NULL;
	if (!msg)
		return 0;

	// Allocate enough starting space for most bot commands
	*argv = malloc_w(size * sizeof(char *));

	// split parameters separated by space or tab
	(*argv)[argc] = strtok_r(msg, " \t", &savedptr);
	while ((*argv)[argc]) {
		if (argc == size - 1) { // Double the array if it gets full
			*argv = realloc_w(*argv, size * 2 * sizeof(char *));
			size *= 2;
		}
		(*argv)[++argc] = strtok_r(NULL, " \t", &savedptr);
	}
	if (!argc) {
		free(*argv);
		*argv = NULL;
	}
	return argc;
}
Esempio n. 4
0
// Return 0 on OK, -1 on error, 1 when there is no more to read.
static int read_next_data(FILE *fp, struct rblk *rblk, int ind, int r)
{
    char cmd='\0';
    size_t bytes;
    unsigned int len;
    char buf[5];
    // FIX THIS: Check for the appropriate return value that means there
    // is no more to read.
    if(fread(buf, 1, 5, fp)!=5) return 1;
    if((sscanf(buf, "%c%04X", &cmd, &len))!=2)
    {
        logp("sscanf failed in %s: %s\n", __func__, buf);
        return -1;
    }
    if(cmd!=CMD_DATA)
    {
        logp("unknown cmd in %s: %c\n", __func__, cmd);
        return -1;
    }
    if(!(rblk[ind].readbuf[r].buf=
                (char *)realloc_w(rblk[ind].readbuf[r].buf, len, __func__)))
        return -1;
    if((bytes=fread(rblk[ind].readbuf[r].buf, 1, len, fp))!=len)
    {
        logp("Short read: %d wanted: %d\n", (int)bytes, (int)len);
        return -1;
    }
    rblk[ind].readbuf[r].len=len;
    //printf("read: %d:%d %04X\n", r, len, r);

    return 0;
}
Esempio n. 5
0
int do_get_entries_in_directory(DIR *directory, struct dirent ***nl,
	int *count, int (*compar)(const void *, const void *))
{
	int status;
	int allocated=0;
	struct dirent **ntmp=NULL;
	struct dirent *entry=NULL;
	struct dirent *result=NULL;

	// This here is doing a funky kind of scandir/alphasort
	// that can also run on Windows.
	while(1)
	{
		char *p;
		if(!(entry=(struct dirent *)malloc_w(
		  sizeof(struct dirent)+fs_name_max+100, __func__)))
			goto error;
		status=readdir_r(directory, entry, &result);
		if(status || !result)
		{
			free_v((void **)&entry);
			break;
		}

		p=entry->d_name;
		ASSERT(fs_name_max+1 > (int)sizeof(struct dirent)+strlen(p));

		if(!p
		  || !strcmp(p, ".")
		  || !strcmp(p, ".."))
		{
			free_v((void **)&entry);
			continue;
		}

		if(*count==allocated)
		{
			if(!allocated) allocated=10;
			else allocated*=2;

			if(!(ntmp=(struct dirent **)
			  realloc_w(*nl, allocated*sizeof(**nl), __func__)))
				goto error;
			*nl=ntmp;
		}
		(*nl)[(*count)++]=entry;
	}
	if(*nl && compar) qsort(*nl, *count, sizeof(**nl), compar);
	return 0;
error:
	free_v((void **)&entry);
	if(*nl)
	{
		int i;
		for(i=0; i<*count; i++)
			free_v((void **)&((*nl)[i]));
		free_v((void **)nl);
	}
	return -1;
}
Esempio n. 6
0
static void ioevent_list_grow(struct ioevent_list *list)
{
	list->size++;
	list->ioevent=(struct ioevent *)
		realloc_w(list->ioevent,
			list->size*sizeof(struct ioevent), __func__);
	fail_unless(list->ioevent!=NULL);
}
Esempio n. 7
0
// Return -1 or error, 0 on OK.
int scores_grow(struct scores *scores, size_t count)
{
	if(!scores || !count) return 0;
	scores->size=count;
	if(!(scores->scores=(uint16_t *)realloc_w(scores->scores,
		sizeof(uint16_t)*scores->size, __func__)))
			return -1;
	return 0;
}
Esempio n. 8
0
static int get_files_in_directory(DIR *directory, struct dirent ***nl, int *count)
{
	int status;
	int allocated=0;
	struct dirent **ntmp=NULL;
	struct dirent *entry=NULL;
	struct dirent *result=NULL;

	/* Graham says: this here is doing a funky kind of scandir/alphasort
	   that can also run on Windows.
	   TODO: split into a scandir function
	*/
	while(1)
	{
		char *p;
		if(!(entry=(struct dirent *)malloc(
			sizeof(struct dirent)+name_max+100)))
		{
			log_out_of_memory(__func__);
			return -1;
		}
		status=readdir_r(directory, entry, &result);
		if(status || !result)
		{
			free(entry);
			break;
		}

		p=entry->d_name;
		ASSERT(name_max+1 > (int)sizeof(struct dirent)+strlen(p));

		/* Skip `.', `..', and excluded file names.  */
		if(!p || !strcmp(p, ".") || !strcmp(p, ".."))
		{
			free(entry);
			continue;
		}

		if(*count==allocated)
		{
			if(!allocated) allocated=10;
			else allocated*=2;

			if(!(ntmp=(struct dirent **)
			  realloc_w(*nl, allocated*sizeof(**nl), __func__)))
			{
				free(entry);
				return -1;
			}
			*nl=ntmp;
		}
		(*nl)[(*count)++]=entry;
	}
	if(*nl) qsort(*nl, *count, sizeof(**nl),
		(int (*)(const void *, const void *))myalphasort);
	return 0;
}
Esempio n. 9
0
int add_to_sbufl_arr(struct sbuf ***sblist, struct sbuf *sb, int *count)
{
        struct sbuf **sbtmp=NULL;
        if(!(sbtmp=(struct sbuf **)realloc_w(*sblist,
                ((*count)+1)*sizeof(struct sbuf *), __func__)))
         	       return -1;
        *sblist=sbtmp;

        (*sblist)[(*count)++]=sb;

        return 0;
}
Esempio n. 10
0
struct candidate *candidates_add_new(void)
{
	struct candidate *candidate;

	if(!(candidate=candidate_alloc())) return NULL;

	if(!(candidates=(struct candidate **)realloc_w(candidates,
		(candidates_len+1)*sizeof(struct candidate *), __func__)))
			return NULL;
	candidates[candidates_len++]=candidate;
	return candidate;
}
Esempio n. 11
0
int del_from_sbufl_arr(struct sbuf ***sblist, int *count)
{
        struct sbuf **sbtmp=NULL;

	(*count)--;
	if((*sblist)[*count]) sbuf_free(&((*sblist)[*count]));
        if(*count && !(sbtmp=(struct sbuf **)realloc_w(*sblist,
                (*count)*sizeof(struct sbuf *), __func__)))
         	       return -1;
        *sblist=sbtmp;

	return 0;
}
Esempio n. 12
0
File: xattr.c Progetto: EmisFR/burp
static int append_to_extrameta(const char *toappend, char metasymbol,
	char **xattrtext, size_t *xlen, ssize_t totallen)
{
	char tmp3[10];
	size_t newlen=0;
	snprintf(tmp3, sizeof(tmp3), "%c%08X",
		metasymbol, (unsigned int)totallen);
	newlen=(*xlen)+9+totallen;
	if(!(*xattrtext=(char *)
		realloc_w(*xattrtext, newlen, __func__)))
			return -1;
	memcpy((*xattrtext)+(*xlen), tmp3, 9);
	(*xlen)+=9;
	memcpy((*xattrtext)+(*xlen), toappend, totallen);
	(*xlen)+=totallen;
	return 0;
}
Esempio n. 13
0
// Return 0 for OK, -1 for error, 1 for finished reading the file.
static int get_next_set_of_hooks(struct hooks **hnew, struct sbuf *sb,
	struct fzp *spzp, char **path, uint64_t **fingerprints, size_t *len)
{
	struct blk blk;
	while(1)
	{
		switch(sbuf_fill_from_file(sb, spzp, NULL, NULL))
		{
			case -1: goto error;
			case 1:
				// Reached the end.
				if(hooks_alloc(hnew, path, fingerprints, len))
					goto error;
				return 1;
		}
		if(sb->path.cmd==CMD_MANIFEST)
		{
			if(hooks_alloc(hnew, path, fingerprints, len))
				break;
			*path=sb->path.buf;
			sb->path.buf=NULL;
			sbuf_free_content(sb);
			if(*hnew) return 0;
		}
		else if(sb->path.cmd==CMD_FINGERPRINT)
		{
			if(!(*fingerprints=(uint64_t *)realloc_w(*fingerprints,
				((*len)+1)*sizeof(uint64_t), __func__)))
					goto error;
			if(blk_set_from_iobuf_fingerprint(&blk, &sb->path))
				goto error;
			(*fingerprints)[(*len)++]=blk.fingerprint;
			sbuf_free_content(sb);
		}
		else
		{
			iobuf_log_unexpected(&sb->path, __func__);
			break;
		}
	}

error:
	sbuf_free_content(sb);
	return -1;
}
Esempio n. 14
0
size_t curl_write_memory(char *data, size_t size, size_t elements, void *membuf) {

	struct mem_buffer *mem = membuf;
	size_t total_size = size * elements;

	// Our function will be called as many times as needed by curl_easy_perform to complete the operation so,
	// we increase the size of our buffer each time to accommodate for it (and the null char)
	mem->buffer = realloc_w(mem->buffer, mem->size + total_size + 1);

	// Our mem_buffer struct keeps the current size so far, so we begin writing to the end of it each time
	memcpy(&(mem->buffer[mem->size]), data, total_size);
	mem->size += total_size;
	mem->buffer[mem->size] = '\0';

	// if the return value isn't the total number of bytes that was passed in our function,
	// curl_easy_perform will return an error
	return total_size;
}
Esempio n. 15
0
static int get_meta(
	struct asfd *asfd,
	struct cntr *cntr,
	char **metadata,
	size_t *metalen)
{
	int ret=-1;
	struct iobuf *rbuf=asfd->rbuf;

	while(1)
	{
		iobuf_free_content(rbuf);
		if(asfd->read(asfd))
			goto end;

		switch(rbuf->cmd)
		{
			case CMD_DATA:
				if(!(*metadata=(char *)realloc_w(*metadata,
					(*metalen)+rbuf->len, __func__)))
						goto end;
				memcpy((*metadata)+(*metalen),
					rbuf->buf, rbuf->len);
				*metalen+=rbuf->len;
				break;
			case CMD_END_FILE:
				ret=0;
				goto end;
			case CMD_MESSAGE:
			case CMD_WARNING:
				log_recvd(rbuf, cntr, 0);
				break;
			default:
				iobuf_log_unexpected(rbuf, __func__);
				goto end;
		}
	}

end:
	iobuf_free_content(rbuf);
	return ret;
}
Esempio n. 16
0
static int process_files_in_directory(struct asfd *asfd, struct dirent **nl,
	int count, int *rtn_stat, char **link, size_t len, size_t *link_len,
	struct conf *conf, FF_PKT *ff_pkt, dev_t our_device)
{
	int m=0;
	for(m=0; m<count; m++)
	{
		size_t i;
		char *p=NULL;
		char *q=NULL;

		p=nl[m]->d_name;

		if(strlen(p)+len>=*link_len)
		{
			*link_len=len+strlen(p)+1;
			if(!(*link=(char *)
			  realloc_w(*link, (*link_len)+1, __func__)))
				return -1;
		}
		q=(*link)+len;
		for(i=0; i<strlen(nl[m]->d_name); i++)
			*q++=*p++;
		*q=0;
		ff_pkt->flen=i;

		if(file_is_included_no_incext(conf, *link))
		{
			*rtn_stat=find_files(asfd, ff_pkt,
				conf, *link, our_device, false);
		}
		else
		{
			struct strlist *x;
			// Excluded, but there might be a subdirectory that is
			// included.
			for(x=conf->incexcdir; x; x=x->next)
			{
				if(x->flag
				  && is_subdir(*link, x->path))
				{
					struct strlist *y;
					if((*rtn_stat=find_files(asfd, ff_pkt,
						conf, x->path,
						our_device, false)))
							break;
					// Now need to skip subdirectories of
					// the thing that we just stuck in
					// find_one_file(), or we might get
					// some things backed up twice.
					for(y=x->next; y; y=y->next)
						if(is_subdir(x->path, y->path))
							y=y->next;
				}
			}
		}
		free_v((void **)&(nl[m]));
		if(*rtn_stat) break;
	}
	return 0;
}
Esempio n. 17
0
File: xattr.c Progetto: EmisFR/burp
static int get_toappend(struct asfd *asfd, const char *path,
	char **toappend, const char *xattrlist, ssize_t len, ssize_t *totallen,
	int have_acl,
	struct cntr *cntr)
{
	char *val=NULL;
	const char *z=NULL;
	ssize_t maxlen=0xFFFFFFFF/2;

	for(z=xattrlist; z-xattrlist < len; z=strchr(z, '\0')+1)
	{
		char tmp1[9];
		char tmp2[9];
		ssize_t vlen;
		ssize_t zlen=0;
		ssize_t newlen=0;

		free_w(&val);

		if((zlen=strlen(z))>maxlen)
		{
			logw(asfd, cntr,
				"xattr element of '%s' too long: %zd\n",
				path, zlen);
			goto carryon;
		}

		if(have_acl && in_skiplist(z))
			continue;

		if((vlen=lgetxattr(path, z, NULL, 0))<0)
		{
			logw(asfd, cntr,
				"could not lgetxattr on %s for %s: %zd %s\n",
				path, z, vlen, strerror(errno));
			continue;
		}
		if(vlen)
		{
			if(!(val=(char *)malloc_w(vlen+1, __func__)))
				goto error;
			if((vlen=lgetxattr(path, z, val, vlen))<0)
			{
				logw(asfd, cntr,
				  "could not lgetxattr %s for %s: %zd %s\n",
					path, z, vlen, strerror(errno));
				continue;
			}
			val[vlen]='\0';

			if(vlen>maxlen)
			{
				logw(asfd, cntr,
					"xattr value of '%s' too long: %zd\n",
					path, vlen);
				goto carryon;
			}
		}

		snprintf(tmp1, sizeof(tmp1), "%08X", (unsigned int)zlen);
		snprintf(tmp2, sizeof(tmp2), "%08X", (unsigned int)vlen);
		newlen=(*totallen)+8+zlen+8+vlen;
		if(!(*toappend=(char *)realloc_w(*toappend, newlen, __func__)))
			goto error;
		memcpy((*toappend)+(*totallen), tmp1, 8);
		*totallen+=8;
		memcpy((*toappend)+(*totallen), z, zlen);
		*totallen+=zlen;
		memcpy((*toappend)+(*totallen), tmp2, 8);
		*totallen+=8;
		memcpy((*toappend)+(*totallen), val, vlen);
		*totallen+=vlen;

		if(*totallen>maxlen)
		{
			logw(asfd, cntr,
				"xattr length of '%s' grew too long: %zd\n",
				path, *totallen);
			goto carryon;
		}
	}

	free_w(&val);
	return 0;
error:
	free_w(&val);
	free_w(toappend);
	return -1;
carryon:
	free_w(&val);
	free_w(toappend);
	return 0;
}
Esempio n. 18
0
File: xattr.c Progetto: EmisFR/burp
int get_xattr(struct asfd *asfd, const char *path,
	char **xattrtext, size_t *xlen, struct cntr *cntr)
{
	int i=0;
	ssize_t maxlen=0xFFFFFFFF/2;

	for(i=0; i<(int)(sizeof(namespaces)/sizeof(int)); i++)
	{
		int j=0;
		ssize_t len=0;
		int have_acl=0;
		char *xattrlist=NULL;
		char *cnamespace=NULL;
		ssize_t totallen=0;
		char *toappend=NULL;
		char z[BSD_BUF_SIZE]="";
		char cattrname[BSD_BUF_SIZE]="";
		if((len=extattr_list_link(path, namespaces[i], NULL, 0))<0)
		{
			logw(asfd, cntr, "could not extattr_list_link of '%s': %zd\n",
				path, len);
			return 0; // carry on
		}
		if(!len) continue;
		if(xattrtext && *xattrtext)
		{
			// Already have some meta text, which means that some
			// ACLs were set.
			have_acl++;
		}
		if(!(xattrlist=(char *)calloc_w(1, len+1, __func__)))
			return -1;
		if((len=extattr_list_link(path, namespaces[i], xattrlist, len))<=0)
		{
			logw(asfd, cntr, "could not extattr_list_link '%s': %zd\n",
				path, len);
			free_w(&xattrlist);
			return 0; // carry on
		}
		xattrlist[len]='\0';

		if(extattr_namespace_to_string(namespaces[i], &cnamespace))
		{
			logp("Failed to convert %d into namespace on '%s'\n",
				 namespaces[i], path);
			free_w(&xattrlist);
			return 0; // carry on
		}


		for(j=0; j<(int)len; j+=xattrlist[j]+1)
		{
			int cnt=0;
			char tmp1[9];
			char tmp2[9];
			size_t newlen=0;
			size_t zlen=0;
			ssize_t vlen=0;
			char *val=NULL;
			cnt=xattrlist[j];
			if(cnt>((int)sizeof(cattrname)-1))
				cnt=((int)sizeof(cattrname)-1);
			strncpy(cattrname, xattrlist+(j+1), cnt);
			cattrname[cnt]='\0';
			snprintf(z, sizeof(z), "%s.%s",
				cnamespace, cattrname);

			if(have_acl && in_skiplist(z))
				continue;
			zlen=strlen(z);
			//printf("\ngot: %s (%s)\n", z, path);

			if((vlen=extattr_list_link(path, namespaces[i],
				xattrlist, len))<0)
			{
				logw(asfd, cntr, "could not extattr_list_link on %s for %s: %zd\n", path, cnamespace, vlen);
				continue;
			}
			if(vlen)
			{
				if(!(val=(char *)malloc_w(vlen+1, __func__)))
				{
					free_w(&xattrlist);
					free_w(&toappend);
					return -1;
				}
				if((vlen=extattr_get_link(path, namespaces[i],
					cattrname, val, vlen))<0)
				{
					logw(asfd, cntr, "could not extattr_list_link %s for %s: %zd\n", path, cnamespace, vlen);
					free_w(&val);
					continue;
				}
				val[vlen]='\0';

				if(vlen>maxlen)
				{
					logw(asfd, cntr, "xattr value of '%s' too long: %zd\n",
						path, vlen);
					free_w(&toappend);
					free_w(&val);
					break;
				}
			}

			snprintf(tmp1, sizeof(tmp1), "%08X", (unsigned int)zlen);
			snprintf(tmp2, sizeof(tmp2), "%08X", (unsigned int)vlen);
			newlen=totallen+8+zlen+8+vlen;
			if(!(toappend=(char *)realloc_w(toappend, newlen, __func__)))
			{
				free_w(&val);
				free_w(&xattrlist);
				return -1;
			}
			memcpy(toappend+totallen, tmp1, 8);
			totallen+=8;
			memcpy(toappend+totallen, z, zlen);
			totallen+=zlen;
			memcpy(toappend+totallen, tmp2, 8);
			totallen+=8;
			memcpy(toappend+totallen, val, vlen);
			totallen+=vlen;
			free_w(&val);

			if(totallen>maxlen)
			{
				logw(asfd, cntr,
				  "xattr length of '%s' grew too long: %lu\n",
				  path, (unsigned long)totallen);
				free_w(&val);
				free_w(&toappend);
				free_w(&xattrlist);
				return 0; // carry on
			}
		}

		if(toappend)
		{
			if(append_to_extrameta(toappend, META_XATTR_BSD,
				xattrtext, xlen, totallen))
			{
				free_w(&toappend);
				free_w(&xattrlist);
				return -1;
			}
		}
		free_w(&toappend);
		free_w(&xattrlist);
	}

	return 0;
}