mdatat~1.c

100 病毒源碼,原始碼,無毒 ......

/* begin of History */

int History_write(gzFile *f, void *d) {
	data_History *data = d;
	
	gzwrite(f, data->string, strlen(data->string));
	gzprintf(f, "\n%d,%d,%d,%ld,%ld,%ld,%ld,%ld,%.0f\n", 
		data->year,
		data->month,
		data->count,
		data->pages,
		data->files,
		data->hits,
		data->visits,
		data->hosts,
		data->xfersize);
	
	return 0;
}

int History_destroy(void *d) {
	data_History *data = d;
	
	if (data->string != NULL) free(data->string);
	if (data != NULL) free(data);
	
	return 0;
}

int History_setdata(data_History *data, const char *str, int count,
	int year, int month, int pages, int hits, int files,
	int visits, int hosts, double xfersize) {
	
	data->string = malloc(strlen(str)+1);
	strcpy(data->string, str);
	
	data->count	= count;
	
	data->month	= month;
	data->year	= year;
	
	data->pages	= pages;
	data->hits	= hits;
	data->files	= files;
	data->visits	= visits;
	data->hosts	= hosts;
	data->xfersize	= xfersize;
	
	return 0;
}

int History_read(void *data, gzFile *f) {
	char *_str = NULL, *_year = NULL;
	int year, month, pages, count, files, hits, visits, hosts;
	double xfersize;
	
	pcre *match;
	const char *errptr;
	int erroffset = 0;
#define N 20 + 1
	int ovector[3 * N], n;
	const char **list;
	
	if ((_str = _getline(f)) == NULL) return -1;
	
	if (*_str == '\0') {
		free(_str);
		return -1;
	}
	
	if (*_str == '#') {
		free(_str);
		return 0;
	}
	
	if ((_year = _getline(f)) == NULL) return -1;
	
	/* remove the newline */
	_str[strlen(_str)-1] = '\0';
	
	if ((match = pcre_compile(
		"^([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+)$", 
		0, &errptr, &erroffset, NULL)) == NULL) {
		
		fprintf(stderr, "%s.%d: rexexp compilation error at %s\n", __FILE__, __LINE__, errptr);
		
		return -1;
	} 
	
	if ((n = pcre_exec(match, NULL, _year, strlen(_year), 0, 0, ovector, 3 * N)) < 0) {
		if (n == PCRE_ERROR_NOMATCH) {
			fprintf(stderr, "%s.%d: string doesn't match: %s\n", __FILE__, __LINE__, _year);
		} else {
			fprintf(stderr, "%s.%d: execution error while matching: %d\n", __FILE__, __LINE__, n);
		}
		return -1;
	}
#undef N	
	
	pcre_get_substring_list(_year, ovector, n, &list);
	
	year	= strtol(list[1], NULL, 10);
	month	= strtol(list[2], NULL, 10);
	count	= strtol(list[3], NULL, 10);
	pages	= strtol(list[4], NULL, 10);
	files	= strtol(list[5], NULL, 10);
	hits	= strtol(list[6], NULL, 10);
	visits	= strtol(list[7], NULL, 10);
	hosts	= strtol(list[8], NULL, 10);
	xfersize = strtod(list[9], NULL);
	
	History_setdata(data, _str, count,
		year, month, pages, hits, files,
		visits, hosts, xfersize);
	
	free(_str);
	free(_year);
	free(list);
	free(match);
	
	return 0;
}

int History_append(void *d, void *s) {
	data_History *data = d;
	data_History *src = s;
	
	data->count	= src->count;
	
	data->month	= src->month;
	data->year	= src->year;
	
	data->pages	= src->pages;
	data->hits	= src->hits;
	data->files	= src->files;
	data->visits	= src->visits;
	data->hosts	= src->hosts;
	data->xfersize	= src->xfersize;
	
	return 0;
}

data_History *History_init() {
	data_History *data = malloc(sizeof(data_History));
	
	/* functions */
	data->destructor	= History_destroy;
	data->write		= History_write;
	data->read		= History_read;
	data->copy		= NULL;
	data->append		= History_append;
	
	data->string	= NULL;
	
	data->count	= 0;
	
	data->month	= 0;
	data->year	= 0;
	
	data->pages	= 0;
	data->hits	= 0;
	data->files	= 0;
	data->visits	= 0;
	data->hosts	= 0;
	data->xfersize	= 0;
	
	return data;
}

data_History *createHistory(mstate *state) {
	data_History *data = History_init();
	char buf[7];
	long i, pages, hits, files, visits, hosts, last_day = 0;
	double xfersize;
	struct tm *tm;
	mstate_web *staweb;
	
	tm = localtime(&(state->timestamp));
	
	sprintf(buf, "%04i%02i", state->year, state->month);
	
	pages	= 0;
	hits	= 0;
	files	= 0;
	visits	= 0;
	hosts	= 0;
	xfersize = 0;
	
	if (state->ext && state->ext_type == M_STATE_TYPE_WEB) {
		staweb = state->ext;
		
		for ( i = 0; i < 31; i++) {
			files		+= staweb->days[i].files;
			xfersize	+= staweb->days[i].xfersize;
			hits		+= staweb->days[i].hits;
			hosts		+= staweb->days[i].hosts;
			pages		+= staweb->days[i].pages;
			visits		+= staweb->days[i].visits;
			if (staweb->days[i].hits) last_day = i+1;
		}
	}
	
	History_setdata(data, buf, last_day, 
		state->year, state->month, 
		pages, hits, files,
		visits, hosts, xfersize);
	
	return data;
}

/* end of History */


/* begin of BrokenLink */

int BrokenLink_write(gzFile *f, void *d) {
	data_BrokenLink *data = d;
	
	gzwrite(f, data->string, strlen(data->string));
	gzwrite(f, "\n", strlen("\n"));
	gzwrite(f, data->referrer, strlen(data->referrer));
	gzprintf(f, "\n%d,%d,%ld\n", 
		data->count,
		data->type,
		data->timestamp);
	
	return 0;
}

int BrokenLink_destroy(void *d) {
	data_BrokenLink *data = d;
	
	if (data->string != NULL) free(data->string);
	if (data->referrer != NULL) free(data->referrer);
	if (data != NULL) free(data);
	
	return 0;
}

int BrokenLink_setdata(data_BrokenLink *data, char *str, int count, 
	int type, time_t timestamp, char *referrer) {
	
	data->string = malloc(strlen(str)+1);
	strcpy(data->string, str);
	
	if (referrer) {
		data->referrer = malloc(strlen(referrer)+1);
		strcpy(data->referrer, referrer);
	} else {
		data->referrer = malloc(strlen("-")+1);
		strcpy(data->referrer, "-");
	}
	
	data->count	= count;
	data->type	= type;
	data->timestamp	= timestamp;
	
	return 0;
}

int BrokenLink_read(void *data, gzFile *f) {
	char *_s, *_ls, *_c;
	int count, type, tstamp;
	
	pcre *match;
	const char *errptr;
	int erroffset = 0;
#define N 20 + 1
	int ovector[3 * N], n;
	const char **list;
	
	if ((_s = _getline(f)) == NULL) return -1;
	
	if (*_s == '\0') {
		free(_s);
		return -1;
	}
	if (mstate_is_section_end(_s)) {
		free(_s);
		return 0;
	}
	
	if ((_ls = _getline(f)) == NULL) return -1;
	
	if (*_ls == '\0') {
		free(_ls);
		free(_s);
		return -1;
	}
	
	if ((_c = _getline(f)) == NULL) return -1;
	
	if (*_c == '\0') {
		free(_s);
		free(_ls);
		free(_c);
		return -1;
	}
	
	/* remove the newline */
	_s[strlen(_s)-1] = '\0';
	_ls[strlen(_ls)-1] = '\0';
	
	if ((match = pcre_compile(
		"^([0-9]+),([0-9]+),([0-9]+)$", 
		0, &errptr, &erroffset, NULL)) == NULL) {
		
		fprintf(stderr, "%s.%d: rexexp compilation error at %s\n", __FILE__, __LINE__, errptr);
		
		
		return -1;
	} 
	
	if ((n = pcre_exec(match, NULL, _c, strlen(_c), 0, 0, ovector, 3 * N)) < 0) {
		if (n == PCRE_ERROR_NOMATCH) {
			fprintf(stderr, "%s.%d: string doesn't match: %s\n", __FILE__, __LINE__, _c);
		} else {
			fprintf(stderr, "%s.%d: execution error while matching: %d\n", __FILE__, __LINE__, n);
		}
		return -1;
	}
#undef N	
	
	pcre_get_substring_list(_c, ovector, n, &list);
	
	count = strtol(list[1], NULL, 10);
	type = strtol(list[2], NULL, 10);
	tstamp = strtol(list[3], NULL, 10);
	
	BrokenLink_setdata(data, _s, count, type, tstamp, _ls);
	
	free(_s);
	free(_ls);
	free(_c);
	free(list);
	free(match);
	
	return 0;
}

int BrokenLink_append(void *d, void *s) {
	data_BrokenLink *data = d;
	data_BrokenLink *src = s;
	
	if (data->referrer != NULL) free(data->referrer);
	data->referrer = malloc(strlen(src->referrer)+1);
	strcpy(data->referrer, src->referrer);
	
	data->timestamp	= src->timestamp;
	data->count	+= src->count;
	
	return 0;
}

void *BrokenLink_copy(void *d) {
	data_BrokenLink *data = BrokenLink_init();
	data_BrokenLink *_data = d;
	
	BrokenLink_setdata(data, _data->string, _data->count, _data->type, _data->timestamp, _data->referrer);
	
	
	return data;
}

data_BrokenLink *BrokenLink_init() {
	data_BrokenLink *data = malloc(sizeof(data_BrokenLink));
	
	/* functions */
	data->destructor	= BrokenLink_destroy;
	data->write		= BrokenLink_write;
	data->read		= BrokenLink_read;
	data->copy		= BrokenLink_copy;
	data->append		= BrokenLink_append;
	
	data->string	= NULL;
	data->referrer	= NULL;
	
	data->count	= 0;
	data->type	= 0;
	data->timestamp	= 0;
	
	return data;
}



data_BrokenLink	*createBrokenLink(char *str, int count, int type, time_t timestamp, char *referrer) {
	data_BrokenLink *data = BrokenLink_init();
	
	BrokenLink_setdata(data, str, count, type, timestamp, referrer);
	
	return data;
}

/* end of BrokenLink */


/* begin of State */

int State_write(gzFile *f, void *d) {
	return 0;
}

int State_destroy(void *d) {
	data_State *data = d;
	
	if (data->string != NULL)	free(data->string);
	if (data->state != NULL)	mstate_free(data->state);
	if (data->history != NULL)	mlist_free(data->history);
	if (data != NULL)	free(data);
	
	return 0;
}

int State_setdata(data_State *data, char *str, mstate *state, mlist *hist) {
	data->string = malloc(strlen(str)+1);
	strcpy(data->string, str);
	
	data->state = state ? state : mstate_init();
	data->history = hist ? hist : mlist_init();
	
	data->count	= 0;
	data->type	= 0;
	
	return 0;
}

int State_read(void *data, gzFile *f) {
	return 0;
}

int State_append(void *d, void *s) {
	return 0;
}

void *State_copy(void *d) {
	return NULL;
}

data_State *State_init() {
	data_State *data = malloc(sizeof(data_State));
	
	/* functions */
	data->destructor	= State_destroy;
	data->write		= State_write;
	data->read		= State_read;
	data->copy		= State_copy;
	data->append		= State_append;
	
	data->string	= NULL;
	data->state	= NULL;
	data->history	= NULL;
	
	data->count	= 0;
	data->type	= 0;
	
	return data;
}

data_State	*createState(char *str, mstate *state, mlist *hist) {
	data_State *data = State_init();
	
	if (State_setdata(data, str, state, hist)) {
		data->destructor(data);
		data = NULL;
	}
	
	return data;
}

/* end of State */

/* begin of Match */

int Match_write(gzFile *f, void *d) {
	return 0;
}

int Match_destroy(void *d) {
	data_Match *data = d;
	
	if (data->string != NULL) free(data->string);
	if (data->match != NULL) free(data->match);
	if (data != NULL) free(data);
	
	return 0;
}

int Match_setdata(data_Match *data, char *match, char *string) {
	const char *errstr;
	int errofs;
	
	data->string = malloc(strlen(string)+1);
	strcpy(data->string, string);
	
	data->match	= pcre_compile(match, 0, &errstr, &errofs, NULL);
	
	data->count	= 0;
	data->type	= 0;
	
	if (data->match == NULL) {
		fprintf(stderr, "%s.%d: regex compilation error: %s\n", __FILE__, __LINE__, errstr);
		return -1;
	}
	
	return 0;
}

int Match_read(void *data, gzFile *f) {
	return 0;
}

int Match_append(void *d, void *s) {
	return 0;
}

void *Match_copy(void *d) {
	return NULL;
}

data_Match *Match_init() {
	data_Match *data = malloc(sizeof(data_Match));
	
	/* functions */
	data->destructor	= Match_destroy;
	data->write		= Match_write;
	data->read		= Match_read;
	data->copy		= Match_copy;
	data->append		= Match_append;
	
	data->string	= NULL;
	data->match	= NULL;
	
	data->count	= 0;
	data->type	= 0;
	
	return data;
}



data_Match *createMatch(char *match, char *string) {
	data_Match *data = Match_init();
	
	if (Match_setdata(data, match, string)) {
		data->destructor(data);
		data = NULL;
	}
	
	return data;
}

/* end of Match */

/* begin of Query */
#ifdef HAVE_LIBADNS
int Query_write(gzFile *f, void *d) {
	return 0;
}

int Query_destroy(void *d) {
	data_Query *data = d;
	
	if (data->string != NULL) free(data->string);
	if (data->query != NULL) free(data->query);
	if (data->resolved_ip != NULL) free(data->resolved_ip);
	if (data != NULL) free(data);
	
	return 0;
}

int Query_setdata(data_Query *data, char *string, adns_query *query) {

	data->string = malloc(strlen(string)+1);
	strcpy(data->string, string);
	
	data->count	= 0;
	data->type	= 0;
	
	data->query	= query;
	
	return 0;
}

int Query_read(void *data, gzFile *f) {
	return 0;
}

int Query_append(void *d, void *s) {
	return 0;
}

void *Query_copy(void *d) {
	return NULL;
}

data_Query *Query_init() {
	data_Query *data = malloc(sizeof(data_Query));
	
	/* functions */
	data->destructor	= Query_destroy;
	data->write		= Query_write;
	data->read		= Query_read;
	data->copy		= Query_copy;
	data->append		= Query_append;
	
	data->string	= NULL;
	data->query	= NULL;
	data->resolved_ip = NULL;
	
	data->count	= 0;
	data->type	= 0;
	
	return data;
}



data_Query *createQuery(char *ip, adns_query * query) {
	data_Query *data = Query_init();
	
	if (Query_setdata(data, ip, query)) {
		data->destructor(data);
		data = NULL;
	}
	
	return data;
}
#endif
/* end of Query */