static int
search_find(struct searchl *search_list, const char * buffer, size_t len) {
struct searchval *search;
LIST_FOREACH(search, search_list, next) {
if (NULL != my_memmem(buffer, len, search->value, search->len)) {
return (0);
}
}
return (-1);
}
static gint pop3_write_msg_to_file(const gchar *file, const gchar *data,
guint len, const gchar *prefix)
{
FILE *fp;
const gchar *prev, *cur;
cm_return_val_if_fail(file != NULL, -1);
if ((fp = g_fopen(file, "wb")) == NULL) {
FILE_OP_ERROR(file, "fopen");
return -1;
}
if (change_file_mode_rw(fp, file) < 0)
FILE_OP_ERROR(file, "chmod");
if (prefix != NULL) {
if (fprintf(fp, "%s\n", prefix) < 0) {
FILE_OP_ERROR(file, "fprintf");
fclose(fp);
claws_unlink(file);
return -1;
}
}
/* +------------------+----------------+--------------------------+ *
* ^data ^prev ^cur data+len-1^ */
prev = data;
while ((cur = (gchar *)my_memmem(prev, len - (prev - data), "\r\n", 2))
!= NULL) {
if ((cur > prev && fwrite(prev, 1, cur - prev, fp) < 1) ||
fputc('\n', fp) == EOF) {
FILE_OP_ERROR(file, "fwrite");
g_warning("can't write to file: %s\n", file);
fclose(fp);
claws_unlink(file);
return -1;
}
if (cur == data + len - 1) {
prev = cur + 1;
break;
}
if (*(cur + 1) == '\n')
prev = cur + 2;
else
prev = cur + 1;
if (prev - data < len - 1 && *prev == '.' && *(prev + 1) == '.')
prev++;
if (prev - data >= len)
break;
}
if (prev - data < len &&
fwrite(prev, 1, len - (prev - data), fp) < 1) {
FILE_OP_ERROR(file, "fwrite");
g_warning("can't write to file: %s\n", file);
fclose(fp);
claws_unlink(file);
return -1;
}
if (data[len - 1] != '\r' && data[len - 1] != '\n') {
if (fputc('\n', fp) == EOF) {
FILE_OP_ERROR(file, "fputc");
g_warning("can't write to file: %s\n", file);
fclose(fp);
claws_unlink(file);
return -1;
}
}
if (fclose(fp) == EOF) {
FILE_OP_ERROR(file, "fclose");
claws_unlink(file);
return -1;
}
return 0;
}
/* length is always !=NULL */
static int xbm_decode(struct cached_image *cimg, unsigned char *data, int length)
{
struct xbm_decoder *deco=(struct xbm_decoder *)cimg->decoder;
/* okurky v decu ;-) */
int a;
int must_return=0;
restart_again:
if (must_return&&!length)return 0;
must_return=0;
a=min(length,XBM_BUFFER_LEN-deco->buffer_pos);
memcpy(deco->buffer+deco->buffer_pos,data,a);
length-=a;
deco->buffer_pos+=a;
if (!deco->buffer_pos)return 0; /* z toho nic plodnyho nevznikne */
data+=a;
if (!deco->in_data_block&&deco->partnum)
{
unsigned char *p;
int a;
int b,d;
p=deco->buffer;
a=deco->buffer_pos;
*(deco->numdest)=xbm_read_num(&p,&a,&(deco->partnum),&d,&b);
/* p i a ukazuje na 1. neciselnej znak (at uz za mezerama bylo cislo nebo nebylo) */
memmove(deco->buffer,p,a);
deco->buffer_pos=a;
if (deco->partnum) {
must_return=1; /* zase konec bufferu */
goto restart_again;
}
}
if (deco->width<0||deco->height<0) /* decoding header */
{
unsigned char *p,*q;
int *d;
int a;
int base, digits;
p=my_memmem(deco->buffer,deco->buffer_pos,cast_uchar "width",5);
q=my_memmem(deco->buffer,deco->buffer_pos,cast_uchar "height",6);
if (!p&&!q) /* sezereme zacatek */
{
int a=deco->buffer_pos>5?deco->buffer_pos:0; /* nesmime ukrast kus width/height */
memmove(deco->buffer,deco->buffer+deco->buffer_pos-a,deco->buffer_pos-a); /* sezereme to pred width/height */
deco->buffer_pos-=a;
must_return=1;
goto restart_again;
}
p=p&&q?min(p,q):max(p,q); /* bereme vetsi, protoze ten 2. je NULL */
memmove(deco->buffer,p,(deco->buffer_pos)+(deco->buffer)-p); /* sezereme to pred width/height */
deco->buffer_pos-=p-deco->buffer;
/* deco->buffer zacina height/width */
if (deco->buffer[0]=='w') {
p=deco->buffer+5;
d=&(deco->width);
}
else {
p=deco->buffer+6;
d=&(deco->height);
}
a=deco->buffer_pos+deco->buffer-p;
xbm_skip_space_tab(&p,&a);
if (!a) {
must_return=1; /* v bufferu je: width/height, whitespace, konec */
goto restart_again;
}
*d=xbm_read_num(&p,&a,&(deco->partnum),&digits, &base);
if (deco->partnum)deco->numdest=d,must_return=1;
/* p i a ukazuje na 1. neciselnej znak (at uz za mezerama bylo cislo nebo nebylo) */
memmove(deco->buffer,p,a);
deco->buffer_pos=a;
goto restart_again;
}
else /* decoding data */
{
unsigned char *p;
int a;
int d=0,b=10;
if (!deco->in_data_block)
{
p=memchr(deco->buffer,'{',deco->buffer_pos);
if (!p) {
deco->buffer_pos=0; /* sezerem celej blok a cekame na zavorku */
must_return=1;
goto restart_again;
}
cimg->width=deco->width;
cimg->height=deco->height;
cimg->buffer_bytes_per_pixel=3;
cimg->red_gamma=display_red_gamma;
cimg->green_gamma=display_green_gamma;
cimg->blue_gamma=display_blue_gamma;
cimg->strip_optimized=0;
if (header_dimensions_known(cimg)) {
img_end(cimg);
return 1;
}
deco->in_data_block=1;
p++;
memmove(deco->buffer,p,deco->buffer_pos+deco->buffer-p); /* sezereme to pred width/height */
deco->buffer_pos-=p-deco->buffer;
deco->image_pos=0;
deco->pixels=deco->width*deco->height;
deco->line_pos=0;
}
p=deco->buffer;
a=deco->buffer_pos;
if (!deco->partnum) xbm_skip_whitespace(&p,&a);
if (!a) {
must_return=1;
goto restart_again;
}
deco->actual_eight=xbm_read_num(&p,&a,&(deco->partnum),&d,&b);
memmove(deco->buffer,p,a);
deco->buffer_pos=a;
if (deco->partnum)must_return=1;
else put_eight(cimg,(b==16&&d>2)||(b==10&&deco->actual_eight>255)?16:8);
if (deco->image_pos>=deco->pixels) {
img_end(cimg);
return 1;
}
goto restart_again;
}
}
int main(int argc, char *argv[]) {
char haystack[10], needle[3];
memmove(haystack, "0123456789", 10);
memmove(needle, "no", 2);
assert(my_memmem(haystack, 10, needle, 2) == NULL);
memmove(needle, "345", 3);
assert(my_memmem(haystack, 10, needle, 3) != NULL);
memmove(needle, "789", 3);
assert(my_memmem(haystack, 10, needle, 3) != NULL);
assert(my_memmem(haystack, 9, needle, 3) == NULL);
memmove(needle, "012", 3);
assert(my_memmem(haystack, 10, needle, 3) != NULL);
assert(my_memmem(NULL, 10, needle, 3) == NULL);
assert(my_memmem(NULL, 10, needle, 3) == NULL);
assert(my_memmem(haystack, 0, needle, 3) == NULL);
assert(my_memmem(haystack, 10, NULL, 3) == NULL);
assert(my_memmem(haystack, 10, needle, 0) == NULL);
assert(my_memmem(haystack, 1, needle, 3) == NULL);
printf("success\n");
return(0);
}
/*--------------------------------------------------------------------------*/
FilterResult wildcard_wc_str(char *pattern, int pattern_len, char *str, int str_len)
/* */
/* Params: */
/* pattern -- the pattern to evaluate */
/* pattern_len -- the length of the pattern (in bytes) */
/* str -- the string to test the pattern on */
/* str_len -- the length of the string */
/* */
/* Returns: */
/* -1 error, 0 success, 1 failure */
/*--------------------------------------------------------------------------*/
{
char *text_start; /* Pointer to the text following the WC(s) */
int text_len; /* Length of the text. */
char *found; /* The start of a string found in a search. */
char *rem_start; /* Start of the remaining characters being searched for. */
int rem_len; /* Length of the remaining charcters being searched for. */
if(pattern_len == 0 && str_len == 0)
{
return FR_EVAL_TRUE;
}
if(pattern_len == 0)
{
return FR_EVAL_FALSE;
}
/***** Find text following wildcard *****/
/**** Find end of WCs ****/
text_start = pattern;
text_len = 0;
while(*text_start == WILDCARD)
{
text_start++;
if(text_start == pattern + pattern_len)
{
/* No following text. Therefore we match. */
return FR_EVAL_TRUE;
}
}
/**** Find end of text. ****/
found = memchr(text_start, WILDCARD, pattern_len - text_len);
if(found == NULL)
{
/* No trailing WC. Set to end. */
found = pattern + pattern_len;
}
text_len = found - text_start;
/***** Look for the text in the source string *****/
rem_start = str;
rem_len = str_len;
while(1)
{
int result;
int match_len;
found = my_memmem(rem_start, rem_len, text_start, text_len, &match_len);
assert(found == NULL || ((found >= rem_start) && (found <= rem_start + rem_len)));
if(found == NULL)
{
/* Desired text is not in the string. */
return FR_EVAL_FALSE;
}
rem_len = str_len - (found - str);
rem_start = found + 1;
/**** Make recursive call. ****/
result = wildcard_wc_str(text_start + text_len, (pattern + pattern_len) - (text_start + text_len), found + text_len, rem_len - match_len);
if(result != FR_EVAL_FALSE)
{
return result;
}
}
/*NOTREACHED*/
assert(0);
}
void aap_handle_connection(struct args *arg)
{
char *buffer, *p, *tmp;
ptrdiff_t pos, buffer_len;
#ifdef HAVE_TIMEOUTS
int *timeout = NULL;
#endif
start:
pos=0;
buffer_len=8192;
if(arg->res.data && arg->res.data_len > 0)
{
p = buffer = arg->res.data;
buffer_len = MAXIMUM(arg->res.data_len,8192);
arg->res.data=0;
}
else
p = buffer = aap_malloc(8192);
if(arg->res.leftovers && arg->res.leftovers_len)
{
if(!buffer)
{
perror("AAP: Failed to allocate buffer (leftovers)");
failed(arg);
return;
}
buffer_len = arg->res.leftovers_len;
MEMCPY(buffer, arg->res.leftovers, arg->res.leftovers_len);
pos = arg->res.leftovers_len;
arg->res.leftovers=0;
if((tmp = my_memmem("\r\n\r\n", 4, buffer, pos)))
goto ok;
p += arg->res.leftovers_len;
}
if(!buffer)
{
perror("AAP: Failed to allocate buffer");
failed(arg);
return;
}
#ifdef HAVE_TIMEOUTS
if( arg->timeout )
timeout = aap_add_timeout_thr(th_self(), arg->timeout);
while( !timeout || !(*timeout) )
#else
while(1)
#endif /* HAVE_TIMEOUTS */
{
ptrdiff_t data_read = fd_read(arg->fd, p, buffer_len-pos);
if(data_read <= 0)
{
#ifdef AAP_DEBUG
fprintf(stderr, "AAP: Read error/eof.\n");
#endif /* AAP_DEBUG */
arg->res.data = buffer;
free_args( arg );
#ifdef HAVE_TIMEOUTS
if( timeout )
{
aap_remove_timeout_thr( timeout );
timeout=NULL;
}
#endif
return;
}
pos += data_read;
if((tmp = my_memmem("\r\n\r\n", 4, MAXIMUM(p-3, buffer),
data_read+(p-3>buffer?3:0))))
goto ok;
p += data_read;
if(pos >= buffer_len)
{
buffer_len *= 2;
if(buffer_len > MAXLEN)
break;
buffer = realloc(buffer, buffer_len);
p = buffer+pos;
if(!buffer)
{
perror("AAP: Failed to allocate memory (reading)");
break;
}
}
}
arg->res.data = buffer;
failed( arg );
#ifdef HAVE_TIMEOUTS
if( timeout )
{
aap_remove_timeout_thr( timeout );
timeout=NULL;
}
#endif
return;
ok:
#ifdef HAVE_TIMEOUTS
if (timeout)
{
aap_remove_timeout_thr( timeout );
timeout=NULL;
}
#endif /* HAVE_TIMEOUTS */
arg->res.body_start = (tmp+4)-buffer;
arg->res.data = buffer;
arg->res.data_len = pos;
switch(parse(arg))
{
case 1:
mt_lock(&queue_mutex);
if(!request)
{
request = last = arg;
arg->next = 0;
}
else
{
last->next = arg;
last = arg;
arg->next = 0;
}
mt_unlock(&queue_mutex);
wake_up_backend();
return;
case -1:
goto start;
case 0:
;
}
}
