mstate.c

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

	}

	while (buffer[strlen(buffer)-1] != '\n') {
		buffer = realloc(buffer, (buf_len+buf_inc) * sizeof(char));
		
		if (!gzgets(f, buffer+strlen(buffer), buf_inc-1)) {
			break;
		}
		
		buf_len += buf_inc;
	}
	
	return buffer;
}

#define M_STATE_DATATYPE_UNSET	0
#define M_STATE_DATATYPE_HASH	1
#define M_STATE_DATATYPE_LONG	2
#define M_STATE_DATATYPE_LIST	3
#define M_STATE_DATATYPE_WEB_ARRAY 4

#define M_STATE_DATASUBTYPE_UNSET	0
#define M_STATE_DATASUBTYPE_STRINT	1
#define M_STATE_DATASUBTYPE_BROKENLINK	2
#define M_STATE_DATASUBTYPE_STR3INT	3
#define M_STATE_DATASUBTYPE_VISIT	4
#define M_STATE_DATASUBTYPE_WEB_ARRAY	5

int mstate_insert_value(void *dest, int type, int subtype, gzFile *f) {
	switch (type) {
		case M_STATE_DATATYPE_LONG: {
			int str = *(int *)(dest);
			char *buffer;
			
			buffer = mstate_getline(f);
			
			str = strtol(buffer, NULL, 10);
			
			*(int *)(dest) = str;
			
			free(buffer);
			buffer = mstate_getline(f);
			free(buffer);
			
			break;
		}
		case M_STATE_DATATYPE_WEB_ARRAY: {
			marray_web *str = (marray_web *)(dest);
			char *buffer;
			int errofs;
			const char *errptr;
#define N 20 + 1
			const char **list;
			int ovector[3 * N], n, i = 0;
			
			pcre *header_match = pcre_compile ("^([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+),([0-9]+)$",
				0, &errptr, &errofs, NULL);
	
			while ((buffer = mstate_getline(f))) {
				if (mstate_is_section_end(buffer)) break;
				if ((n = pcre_exec(header_match, NULL, buffer, strlen(buffer), 0, 0, ovector, 3 * N)) < 0) {
					if (n == PCRE_ERROR_NOMATCH) {
						fprintf(stderr, "%s.%d: string doesn't match: %s\n", __FILE__, __LINE__, buffer);
					} else {
						fprintf(stderr, "%s.%d: execution error while matching: %d\n", __FILE__, __LINE__, n);
					}
					free(buffer);
					return -1;
				}
		
				if (n >= 6) {
					pcre_get_substring_list(buffer, ovector, n, &list);
					
					str[i].hits = strtol(list[1], NULL, 10);
					str[i].files = strtol(list[2], NULL, 10);
					str[i].pages = strtol(list[3], NULL, 10);
					str[i].visits = strtol(list[4], NULL, 10);
					str[i].hosts = strtol(list[5], NULL, 10);
					str[i].xfersize = strtod(list[6], NULL);
					
					free(list);
				}
				free(buffer);
				i++;
			}
			pcre_free(header_match);
			
			break;
		}
		case M_STATE_DATATYPE_HASH: {
			switch(subtype) {
				case M_STATE_DATASUBTYPE_STRINT: {
					data_StrInt *data = StrInt_init();
					mhash **hash = *(mhash ***) dest;
					
					while ((data->read(data, f) == 0)) {
						if (!data->string) {
							data->destructor(data);
							data = NULL;
							break;
						}
						
						mhash_insert(hash, data);
						data = StrInt_init();
					}
					
					if (data)
						data->destructor(data);
					
					break;
				}
				case M_STATE_DATASUBTYPE_STR3INT: {
					data_Str3Int *data = Str3Int_init();
					mhash **hash = *(mhash ***) dest;
					
					while ((data->read(data, f) == 0)) {
						if (!data->string) {
							data->destructor(data);
							data = NULL;
							break;
						}
						
						mhash_insert(hash, data);
						data = Str3Int_init();
					}
					
					if (data)
						data->destructor(data);
					break;
				}
				case M_STATE_DATASUBTYPE_BROKENLINK: {
					data_BrokenLink *data = BrokenLink_init();
					mhash **hash = *(mhash ***) dest;
					
					while ((data->read(data, f) == 0)) {
						if (!data->string) {
							data->destructor(data);
							data = NULL;
							break;
						}
						
						mhash_insert(hash, data);
						data = BrokenLink_init();
					}
					if (data)
						data->destructor(data);
					break;
				}
				default:
					fprintf(stderr, "%s.%d: unknown datasubtype %d\n", __FILE__, __LINE__, subtype);
					return -1;
			}
			break;
		}
		
		case M_STATE_DATATYPE_LIST: {
			switch(subtype) {
				case M_STATE_DATASUBTYPE_STRINT: {
					data_StrInt *data = StrInt_init();
					mlist *list = *(mlist **) dest;
					
					while ((data->read(data, f) == 0)) {
						if (!data->string) {
							data->destructor(data);
							data = NULL;
							break;
						}
						
						mlist_insert(list, data);
						data = StrInt_init();
					}
					
					if (data)
						data->destructor(data);
					break;
				 }
				 case M_STATE_DATASUBTYPE_VISIT: {
					data_Visit *data = Visit_init();
					mlist *list = *(mlist **) dest;
					
					while ((data->read(data, f) == 0)) {
						if (!data->string) {
							data->destructor(data);
							data = NULL;
							break;
						}
						
						mlist_insert(list, data);
						data = Visit_init();
					}
					
					if (data)
						data->destructor(data);
					
					break;
				 }
				 default:
					fprintf(stderr, "%s.%d: unknown datasubtype %d\n", __FILE__, __LINE__, subtype);
					return -1;
			}
			break;
		}
		
		default:
			return -1;
	}
	return 0;
}

typedef struct {
	char	*string;
	int	type;
	int	subtype;
	void	*dest;
} mstate_values;

int mstate_read_web (mconfig *conf, mstate_web *state, gzFile *f, char *key) {
	int i = 0;
	
	const mstate_values state_values[] = {
		{ M_STATE_WEB_ALLVISITTIME, M_STATE_DATATYPE_LONG, M_STATE_DATASUBTYPE_UNSET,	&(state->allvisittime) },
		{ M_STATE_WEB_ALLVISITLEN, M_STATE_DATATYPE_LONG, M_STATE_DATASUBTYPE_UNSET,	&(state->allvisitlength) },
		{ M_STATE_WEB_REQ_URL,	M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STRINT,	&(state->req_url_hash) },
		{ M_STATE_WEB_REQ_METHOD, M_STATE_DATATYPE_HASH, M_STATE_DATASUBTYPE_STRINT,	&(state->req_meth_hash) },
		{ M_STATE_WEB_REQ_PROTOCOL, M_STATE_DATATYPE_HASH, M_STATE_DATASUBTYPE_STRINT,	&(state->req_prot_hash) },
		{ M_STATE_WEB_REF_URL,	M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STRINT,	&(state->ref_url_hash) },
		{ M_STATE_WEB_OS,	M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STR3INT,	&(state->os_hash) },
		{ M_STATE_WEB_USERAGENT, M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STR3INT,	&(state->ua_hash) },
		{ M_STATE_WEB_HOST,	M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STR3INT,	&(state->host_hash) },
		{ M_STATE_WEB_STATUS,	M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STRINT,	&(state->status_hash) },
		{ M_STATE_WEB_EXITPAGES, M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STRINT,	&(state->exit_pages) },
		{ M_STATE_WEB_ENTRYPAGES, M_STATE_DATATYPE_HASH, M_STATE_DATASUBTYPE_STRINT,	&(state->entry_pages) },
		{ M_STATE_WEB_VISIT,	M_STATE_DATATYPE_LIST,	M_STATE_DATASUBTYPE_VISIT,	&(state->visit_list) },
		{ M_STATE_WEB_HOURS,	M_STATE_DATATYPE_WEB_ARRAY, M_STATE_DATASUBTYPE_STRINT,	&(state->hours) },
		{ M_STATE_WEB_DAYS,	M_STATE_DATATYPE_WEB_ARRAY, M_STATE_DATASUBTYPE_STRINT,	&(state->days) },
		{ M_STATE_WEB_COUNTRIES, M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STR3INT,	&(state->country_hash) },
		{ M_STATE_WEB_ROBOTS,	M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STRINT,	&(state->robots) },
		{ M_STATE_WEB_SEARCHSITE, M_STATE_DATATYPE_HASH, M_STATE_DATASUBTYPE_STRINT,	&(state->searchsite) },
		{ M_STATE_WEB_SEARCHSTRING, M_STATE_DATATYPE_HASH, M_STATE_DATASUBTYPE_STRINT,	&(state->searchstring) },
		{ M_STATE_WEB_INT_ERROR, M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_BROKENLINK,	&(state->status_internal_error) },
		{ M_STATE_WEB_MISSING_FILE, M_STATE_DATATYPE_HASH, M_STATE_DATASUBTYPE_BROKENLINK, &(state->status_missing_file) },
		{ M_STATE_WEB_BOOKMARKS, M_STATE_DATATYPE_HASH,	M_STATE_DATASUBTYPE_STRINT,	&(state->bookmarks) },
		{ M_STATE_WEB_INDEXED_PAGES, M_STATE_DATATYPE_HASH, M_STATE_DATASUBTYPE_STRINT,	&(state->indexed_pages) },
		
		{ NULL, M_STATE_DATATYPE_UNSET, M_STATE_DATASUBTYPE_UNSET, NULL}
	};

	while (state_values[i].string) {
		if (!strcmp(state_values[i].string, key))
			break;
		i++;
	}

	if (!state_values[i].string) return -1;
	
	if (mstate_insert_value(state_values[i].dest, state_values[i].type, state_values[i].subtype, f)) {
		return -1;
	}
	
	return 0;
}

int mstate_read_telecom (mconfig *conf, mstate_telecom *state, gzFile *f, char *subsection) {
	return 0;
}

int mstate_read_global (mconfig *conf, mstate *state, gzFile *f, char *subsection) {
	char *buffer;
	int errofs;
	const char *errptr;
#define N 20 + 1
	const char **list;
	int ovector[3 * N], n, i = 0;
			
	pcre *header_match = pcre_compile ("^([0-9]+),([0-9]+),([0-9]+)$",
		0, &errptr, &errofs, NULL);
	
	while ((buffer = mstate_getline(f))) {
		if (mstate_is_section_end(buffer)) break;
		if ((n = pcre_exec(header_match, NULL, buffer, strlen(buffer), 0, 0, ovector, 3 * N)) < 0) {
			if (n == PCRE_ERROR_NOMATCH) {
				fprintf(stderr, "%s.%d: string doesn't match: %s\n", __FILE__, __LINE__, buffer);
			} else {
				fprintf(stderr, "%s.%d: execution error while matching: %d\n", __FILE__, __LINE__, n);
			}
			free(buffer);
			return -1;
		}
		
		if (n >= 3) {
			pcre_get_substring_list(buffer, ovector, n, &list);
					
			state->timestamp = strtol(list[1], NULL, 10);
			state->year = strtol(list[2], NULL, 10);
			state->month = strtol(list[3], NULL, 10);
			
			free(list);
		}
		free(buffer);
		i++;
	}
	pcre_free(header_match);
	
	free(buffer);
	return 0;
}

int mstate_read (mconfig *conf, mstate *state, int year, int month, char *subpath) {
	gzFile  *f;
	char *buffer, cmpbuf[255];
	char filename[255];
	pcre *header_match = NULL;
	const char *errptr;
	int errofs = 0;
#define N 20 + 1
	const char **list;
	int ovector[3 * N], n;
	
	sprintf(cmpbuf, "# %s - %s\n", PACKAGE, STATE_FILE_VERSION);
	
	if (year == 0 || month == 0) {
		sprintf(filename, "%s%s%s/modlogan.state%s", 
			conf->outputdir ? conf->outputdir : ".", 
			subpath ? "/" : "",
			subpath ? subpath : "",
			".gz");
	} else {
		sprintf(filename, "%s%s%s/modlogan_%04d%02d.state%s", 
			conf->outputdir ? conf->outputdir : ".", 
			subpath ? "/" : "",
			subpath ? subpath : "",
			year, month,
			".gz");
	}
	
	if (!(f = gzopen(filename, "rb"))) {
		if (conf->debug_level > 1)
			fprintf(stderr, "%s.%d: %s: %s\n", __FILE__, __LINE__, _("Can't open state file"), strerror(errno));
		return -1;
	}
	
	buffer = mstate_getline(f);
	
	if (strcmp(buffer, cmpbuf)) {
		fprintf(stderr, "%s.%d: %s: \n%s -> %s", __FILE__, __LINE__, _("state file header doesn't match"), buffer, cmpbuf);
		free(buffer);
		return -1;
	}
	free(buffer);
	
	header_match = pcre_compile ("^# -([be])- -([a-z]+)- ([a-z_]+) --$",
		0, &errptr, &errofs, NULL);
	
	while ((buffer = mstate_getline(f))) {
		if (!*buffer) {
			free(buffer);
			break;
		}
		if ((n = pcre_exec(header_match, NULL, buffer, strlen(buffer), 0, 0, ovector, 3 * N)) < 0) {
			if (n == PCRE_ERROR_NOMATCH) {
				fprintf(stderr, "%s.%d: string doesn't match: %s\n", __FILE__, __LINE__, buffer);
			} else {
				fprintf(stderr, "%s.%d: execution error while matching: %d\n", __FILE__, __LINE__, n);
			}
			free(buffer);
			return -1;
		}
		
		if (n >= 3) {
			char header_type = '\0';
			char *section_name, *subsection_name;
			pcre_get_substring_list(buffer, ovector, n, &list);
			
			header_type = *list[1];
			
			if (header_type == 'b') {
			
				section_name = (char *)list[2];
				
				subsection_name = (char *)list[3];
			
				if (strcmp(section_name, M_STATE_SECTION_WEB) == 0) {
					if (state->ext) {
						if (state->ext_type != M_STATE_TYPE_WEB) {
							return -1;
						}
					} else {
						state->ext = mstate_init_web();
						state->ext_type = M_STATE_TYPE_WEB;
					}
				
					mstate_read_web(conf, state->ext, f, subsection_name);
				} else if (strcmp(section_name, M_STATE_SECTION_TELECOM) == 0) {
					if (state->ext) {
						if (state->ext_type != M_STATE_TYPE_WEB) {
							return -1;
						}
					} else {
						state->ext = mstate_init_web();
						state->ext_type = M_STATE_TYPE_WEB;
					}
				
					mstate_read_telecom(conf, state->ext, f, subsection_name);
				} else if (strcmp(section_name, M_STATE_SECTION_GLOBAL) == 0) {
					mstate_read_global(conf, state, f, subsection_name);
				} else {
					printf("--><--\n");
				}
			}
			free(list);
		} else {
			printf("-->\n");
		}
		
		free(buffer);
	}
	
	gzclose(f);
	
	return 0;
}