int test_write_header() { struct setec_astronomy_header w_header, r_header; char temp_file[] = TEST_DATA_DIR "temp"; init_header(&w_header); init_header(&r_header); create_header(&w_header, DEFAULT_IV_LEN, DEFAULT_SALT_LEN, DEFAULT_HASH_COUNT, DEFAULT_PASSWORD, DEFAULT_HASH_LEN); test_equals(write_header(&w_header, temp_file), SA_SUCCESS); test_equals(read_header(&r_header, temp_file), SA_SUCCESS); test_equals(w_header.salt_len, r_header.salt_len); test_equals(w_header.hash_count, r_header.hash_count); test_equals(w_header.hash_len, w_header.hash_len); test_equals(w_header.iv_len, r_header.iv_len); test_equals(strncmp(w_header.salt, r_header.salt, w_header.salt_len), 0); test_equals(strncmp(w_header.hash, r_header.hash, w_header.hash_len), 0); test_equals(strncmp(w_header.iv, r_header.iv, w_header.iv_len), 0); test_equals(strncmp(w_header.hash, r_header.hash, w_header.hash_len), 0); free_header(&w_header); free_header(&r_header); return 0; }
/* free_block -- free a block, merging it with its neighbours */ static header *free_block(header *h, bool mapped) { /* Mapped is true if this memory is being recycled: it's already in the page table, but we'll need to zero it. */ header *prev = left_neighbour(h), *next = right_neighbour(h); /* Base and size of area where page table needs updating */ uchar *pg_memory = h->h_memory; unsigned pg_size = (mapped ? 0 : h->h_size); #ifdef TRACE if (debug['l']) { printf("Freeing block at %p, size %#x\n", h->h_memory, h->h_size); if (prev == NULL) printf("prev=null, "); else printf("prev=%p, ", prev->h_memory); if (next == NULL) printf("next=null\n"); else printf("next=%p\n", next->h_memory); } #endif if (mapped) memset(h->h_memory, 0, h->h_size); if (prev != NULL && prev->h_objsize == 0) { DEBUG_PRINT('l', ("Merging with prev\n")); unlink(prev); prev->h_size += h->h_size; pg_memory = h->h_memory; pg_size = h->h_size; free_header(h); h = prev; } if (next != NULL && next->h_objsize == 0) { DEBUG_PRINT('l', ("Merging with next\n")); unlink(next); next->h_memory = h->h_memory; next->h_size += h->h_size; pg_memory = h->h_memory; pg_size = h->h_size; free_header(h); h = next; } if (pg_size > 0) page_setup(pg_memory, pg_size, h); make_free(h); /* Return the merged block */ return h; }
void free_request(request *req) { uint32_t i; header *h; if(req->path){ free_buffer(req->path); req->path = NULL; } if(req->uri){ free_buffer(req->uri); req->uri = NULL; } if(req->query_string){ free_buffer(req->query_string); req->query_string = NULL; } if(req->fragment){ free_buffer(req->fragment); req->fragment = NULL; } for(i = 0; i < req->num_headers+1; i++){ h = req->headers[i]; if(h){ free_buffer(h->field); free_buffer(h->value); free_header(h); req->headers[i] = NULL; } } ruby_xfree(req); }
int test_read_header() { struct setec_astronomy_header r_header; unsigned char * hash; /* Start off with a good test */ init_header(&r_header); test_equals(read_header(&r_header, GOOD_HEADER_TEST), SA_SUCCESS); /* Check to make sure that the read and write headers are identical */ test_equals(r_header.salt_len, DEFAULT_SALT_LEN); test_equals(r_header.hash_count, DEFAULT_HASH_COUNT); test_equals(r_header.hash_len, DEFAULT_HASH_LEN); test_equals(r_header.iv_len, DEFAULT_IV_LEN); hash = malloc(r_header.hash_len); PKCS5_PBKDF2_HMAC_SHA1(DEFAULT_PASSWORD, strlen(DEFAULT_PASSWORD), r_header.salt, r_header.salt_len, r_header.hash_count*2, r_header.hash_len, hash); test_equals(memcmp(r_header.hash, hash, r_header.hash_len), 0); free(hash); free_header(&r_header); /* Now try to read a header from a file that doesn't exist */ init_header(&r_header); test_equals(read_header(&r_header, "thisfiledoesntexists"), SA_FILE_NOT_FOUND); free_header(&r_header); /* Test against a file that exists but has no data */ init_header(&r_header); test_equals(read_header(&r_header, NO_DATA_TEST), SA_NO_DATA); free_header(&r_header); /* Test against a file that exists and has some but not enough data */ init_header(&r_header); test_equals(read_header(&r_header, NOT_ENOUGH_DATA_TEST), SA_NO_DATA); free_header(&r_header); return UT_SUCCESS; }
static void close_smacker(bgav_demuxer_context_t * ctx) { smacker_priv_t * priv; priv = ctx->priv; if(priv) { free_header(&priv->h); free(priv); } }
static void garmin_txt_rd_deinit(void) { header_type h; for (h = waypt_header; h <= unknown_header; h++) { free_header(h); } gbfclose(fin); xfree(date_time_format); }
void regen_good_header_data() { struct setec_astronomy_header header; remove(GOOD_HEADER_DATA); create_header(&header, DEFAULT_IV_LEN, DEFAULT_SALT_LEN, DEFAULT_HASH_COUNT, DEFAULT_PASSWORD, DEFAULT_HASH_LEN); write_header(&header, GOOD_HEADER_DATA); free_header(&header); }
void regen_file_exists() { struct setec_astronomy_header header; remove(FILE_EXISTS); create_header(&header, DEFAULT_IV_LEN, DEFAULT_SALT_LEN, DEFAULT_HASH_COUNT, DEFAULT_PASSWORD, DEFAULT_HASH_LEN); write_header(&header, FILE_EXISTS); free_header(&header); }
static void parse_header(void) { char *str; int column = -1; free_header(unknown_header); while ((str = csv_lineparse(NULL, "\t", "", column++))) { header_lines[unknown_header][column] = strupper(xstrdup(str)); header_ct[unknown_header]++; if (header_ct[unknown_header] >= MAX_HEADER_FIELDS) break; } }
/* this function is called upon unloading of the mex-file */ void exitFun(void) { int verbose = 1; int rc; if (verbose) { printf("Entering exitFun() routine\n"); } /* tell the tcpserver thread to stop */ pthread_mutex_lock(&mutexstatus); if (tcpserverStatus) { pthread_mutex_unlock(&mutexstatus); mexPrintf("requesting cancelation of tcpserver thread\n"); pthread_cancel(tcpserverThread); pthread_join(tcpserverThread, NULL); } else { pthread_mutex_unlock(&mutexstatus); } /* free the memory that is used for the header, data and events */ free_event(); free_data(); free_header(); /* clean up host/address/socket list and close open sockets */ while (firstHostPortSock != NULL) { host_port_sock_list_item_t *hpsli = firstHostPortSock; if (hpsli->sock > 0) { if (verbose) { printf("Closing socket and "); } close_connection(hpsli->sock); } if (verbose) { printf("cleaning up list entry %s:%i\n",hpsli->hostname, hpsli->port); } FREE(hpsli->hostname); firstHostPortSock = hpsli->next; free(hpsli); } return; }
static IndexFILE *free_index( IndexFILE *indexf ) { IndexFILE *next = indexf->next; SWISH *sw = indexf->sw; int i; /* Close any pending DB */ if ( indexf->DB ) DB_Close(sw, indexf->DB); /* free the meteEntry array */ if ( indexf->header.metaCounter) freeMetaEntries(&indexf->header); /* free the in-use cached meta list */ if ( indexf->meta_list ) efree(indexf->meta_list); /* free the in-use cached property list */ if ( indexf->prop_list ) efree(indexf->prop_list); /* free data loaded into header */ free_header(&indexf->header); /* free array of words for each letter (-k) $$$ eight bit */ for (i = 0; i < 256; i++) if ( indexf->keywords[i]) efree(indexf->keywords[i]); /* free the name of the index file */ efree( indexf->line ); /* free the stem cache if any */ free_word_hash_table( &indexf->hashstemcache); /* finally free up the index itself */ efree( indexf ); return next; }
static void bind_fields(const header_type ht) { int i; char *fields, *c; is_fatal((grid_index < 0) || (datum_index < 0), MYNAME ": Incomplete or invalid file header!"); if (header_ct[unknown_header] <= 0) return; free_header(ht); /* make a copy of headers[ht], uppercase, replace "\t" with "\0" */ i = strlen(headers[ht]); fields = xmalloc(i + 2); strcpy(fields, headers[ht]); strcat(fields, "\t"); c = strupper(fields); while ((c = strchr(c, '\t'))) *c++ = '\0'; for (i = 0; i < header_ct[unknown_header]; i++) { char *name; int field_no; name = header_lines[ht][i] = header_lines[unknown_header][i]; header_lines[unknown_header][i] = NULL; c = fields; field_no = 1; while (*c) { if (strcmp(c, name) == 0) { header_fields[ht][i] = field_no; #if 0 printf("Binding field \"%s\" to internal number %d (%d,%d)\n", name, field_no, ht, i); #endif break; } field_no++; c = c + strlen(c) + 1; } } header_ct[unknown_header] = 0; xfree(fields); }
struct spf_header_field * set_header(const char *ifn) { char str[2048]; struct spf_header_field * p; void free_header(struct spf_header_field *); int i = 0; if ((p = (struct spf_header_field *)malloc((MAX_NUM_HEADER_FIELDS + 1) * sizeof(struct spf_header_field))) == NULL) return(NULL); for (i = 0; i <= MAX_NUM_HEADER_FIELDS; i++) p[i].name = p[i].value = NULL; i = 0; /* source file */ sprintf(str, "%s:%1d", ifn, channel); p[i].name = strdup("source_filename"); p[i++].value = strdup(str); /* frame stuff:_length, shift, rate and pre-emphasis */ sprintf(str, "%f", fm_l / 1000.0); p[i].name = strdup("frame_length"); p[i++].value = strdup(str); sprintf(str, "%f", fm_d / 1000.0); p[i].name = strdup("frame_shift"); p[i++].value = strdup(str); sprintf(str, "%f", emphco); p[i].name = strdup("pre_emphasis"); p[i++].value = strdup(str); /* analysis type */ sprintf(str, "lpc(%d)+cep(%d)", nlpc, numceps); p[i].name = strdup("feature_type"); p[i++].value = strdup(str); /* -- already in mandatory header -- if (flag) { sp_flag_to_str(flag, str); p[i].name = strdup("feature_flag"); p[i++].value = strdup(str); } */ /* miscellaneous parameters */ if (alpha != 0.0) { sprintf(str, "%f", alpha); p[i].name = strdup("frequency_warping"); p[i++].value = strdup(str); } else { p[i].name = strdup("frequency_warping"); p[i++].value = strdup("linear"); } if ((flag & WITHE) && escale != 0.0) { sprintf(str, "%f", escale); p[i].name = strdup("energy_scaling"); p[i++].value = strdup(str); } if (((flag & WITHE) || (flag & WITHZ)) && winlen) { sprintf(str, "%lu", winlen); p[i].name = strdup("segment_length"); p[i++].value = strdup(str); } if (lifter) { sprintf(str, "%d", lifter); p[i].name = strdup("liftering"); p[i++].value = strdup(str); } /* check all fields were set */ while (i) { i--; if (p[i].name == NULL || p[i].value == NULL) { free_header(p); return(NULL); } } return(p); }
/* ---------------------------------- */ int main(int argc, char **argv) { char *ifn, *ofn; /* I/O filenames */ sigstream_t *is; spfstream_t *os; float frate; unsigned short dim; struct spf_header_field * vh = NULL; int status; /* error status */ int read_args(int, char **); struct spf_header_field * set_header(const char *); void free_header(struct spf_header_field *); int cepstral_analysis(sigstream_t *, spfstream_t *); /* ----- process command line ----- */ if (read_args(argc, argv)) return(1); if (optind < argc) ifn = argv[optind++]; else { fprintf(stderr, "slpcep error -- no input filename specified (use --help to get usage)\n"); return(1); } if (optind < argc) ofn = argv[optind++]; else { fprintf(stderr, "slpcep error -- no output filename specified (use --help to get usage)\n"); return(1); } if (optind < argc) { fprintf(stderr, "slpcep error -- invalid number of arguments (use --help to get usage)\n"); return(1); } /* ----- show what was asked to do ----- */ if (trace) { fprintf(stdout, "%s --> %s\n", ifn, ofn); fflush(stdout); } /* ----- open input stream ----- */ if ((is = sig_stream_open(ifn, format, Fs, ibs, swap)) == NULL) { fprintf(stderr, "slpcep error -- cannot open input stream %s\n", ifn); return(SPRO_STREAM_OPEN_ERR); } /* ----- open output stream ----- */ frate = (unsigned long)(fm_d * is->Fs / 1000.0) / is->Fs; /* real frame period */ dim = (flag & WITHE) ? numceps + 1 : numceps; if (with_header) if ((vh = set_header(ifn)) == NULL) { fprintf(stderr, "slpcep error -- cannot allocate memory\n"); sig_stream_close(is); return(SPRO_ALLOC_ERR); } if ((os = spf_output_stream_open(ofn, dim, flag & WITHE, flag, 1.0 / frate, vh, obs)) == NULL) { fprintf(stderr, "slpcep error -- cannot open output stream %s\n", ofn); sig_stream_close(is); free_header(vh); return(SPRO_STREAM_OPEN_ERR); } free_header(vh); if (winlen) set_stream_seg_length(os, winlen); if (escale != 0.0) set_stream_energy_scale(os, escale); /* ----- run LPCC analysis ----- */ if ((status = cepstral_analysis(is, os)) != 0) { fprintf(stderr, "slpcep error -- error processing stream %s\n", ifn); sig_stream_close(is); spf_stream_close(os); return(status); } /* ----- clean ----- */ sig_stream_close(is); spf_stream_close(os); return(0); }
static void checksign(struct mimestack **stack, int *iseof, struct header *h, FILE *fpin, FILE *fpout, int argc, char **argv) { char buf[BUFSIZ]; struct header *h2; char signed_content[TEMPNAMEBUFSIZE]; char signature[TEMPNAMEBUFSIZE]; int signed_file, signature_file; FILE *signed_file_fp, *signature_file_fp; int clos_flag; int need_nl, check_boundary; struct mimestack *b=0; struct mime_header *mh; int qpdecode=0; signed_file=mimegpg_tempfile(signed_content); if (signed_file < 0 || (signed_file_fp=fdopen(signed_file, "w+")) == 0) { if (signed_file > 0) { close(signed_file); unlink(signed_content); } perror("open"); exit(1); } noexec(signed_file_fp); find_boundary(stack, iseof, fpin, NULL, 0); if (*iseof) return; need_nl=0; check_boundary=1; while (!*iseof) { const char *p; if (fgets(buf, sizeof(buf), fpin) == NULL) { *iseof=1; continue; } if (check_boundary && (b=is_boundary(*stack, buf, &clos_flag)) != 0) break; if (need_nl) fprintf(signed_file_fp, "\r\n"); for (p=buf; *p && *p != '\n'; p++) putc(*p, signed_file_fp); need_nl=check_boundary= *p != 0; } if (my_rewind(signed_file_fp) < 0) { perror(signed_content); fclose(signed_file_fp); unlink(signed_content); exit(1); } if (clos_flag) { fclose(signed_file_fp); unlink(signed_content); if (b) pop_mimestack_to(stack, b); find_boundary(stack, iseof, fpin, fpout, 1); return; } h=read_headers(stack, iseof, fpin, fpout, 0); if (!h || !(h2=find_header(h, "content-type:"))) { fclose(signed_file_fp); unlink(signed_content); if (!*iseof) find_boundary(stack, iseof, fpin, fpout, 1); return; } mh=parse_mime_header(h2->header+sizeof("content-type:")-1); if (!mh) { perror("malloc"); free_header(h); fclose(signed_file_fp); unlink(signed_content); exit(1); } if (!mh || strcasecmp(mh->header_name, "application/pgp-signature")) { if (!mh) free_mime_header(mh); free_header(h); fclose(signed_file_fp); unlink(signed_content); if (!*iseof) find_boundary(stack, iseof, fpin, fpout, 1); return; } free_mime_header(mh); /* ** In rare instances, the signature is qp-encoded. */ if ((h2=find_header(h, "content-transfer-encoding:")) != NULL) { mh=parse_mime_header(h2->header +sizeof("content-transfer-encoding:")-1); if (!mh) { perror("malloc"); free_header(h); fclose(signed_file_fp); unlink(signed_content); exit(1); } if (strcasecmp(mh->header_name, "quoted-printable") == 0) qpdecode=1; free_mime_header(mh); } free_header(h); signature_file=mimegpg_tempfile(signature); if (signature_file < 0 || (signature_file_fp=fdopen(signature_file, "w+")) == 0) { if (signature_file > 0) { close(signature_file); unlink(signature); } fclose(signed_file_fp); unlink(signed_content); perror("open"); exit(1); } while (!*iseof) { const char *p; if (fgets(buf, sizeof(buf), fpin) == NULL) { *iseof=1; continue; } if ((b=is_boundary(*stack, buf, &clos_flag)) != 0) break; for (p=buf; *p; p++) { int n; if (!qpdecode) { putc(*p, signature_file_fp); continue; } if (*p == '=' && p[1] == '\n') break; if (*p == '=' && p[1] && p[2]) { n=nybble(p[1]) * 16 + nybble(p[2]); if ( (char)n ) { putc((char)n, signature_file_fp); p += 2; } p += 2; continue; } putc(*p, signature_file_fp); /* If some spits out qp-lines > BUFSIZ, they deserve ** this crap. */ } } fflush(signature_file_fp); if (ferror(signature_file_fp) || fclose(signature_file_fp)) { unlink(signature); fclose(signed_file_fp); unlink(signed_content); perror("open"); exit(1); } dochecksign(*stack, signed_file_fp, fpout, signed_content, signature, argc, argv); fclose(signed_file_fp); unlink(signature); unlink(signed_content); fprintf(fpout, "\n--%s--\n", b->boundary); while (!clos_flag) { if (fgets(buf, sizeof(buf), fpin) == NULL) { *iseof=1; break; } if (!(b=is_boundary(*stack, buf, &clos_flag))) clos_flag=0; } if (b) pop_mimestack_to(stack, b); if (iseof) return; }
static int dosignencode(int dosign, int doencode, int dodecode, FILE *fpin, FILE *fpout, int argc, char **argv) { struct mimestack *boundary_stack=0; int iseof=0; while (!iseof) { static const char ct_s[]="content-type:"; struct header *h=read_headers(&boundary_stack, &iseof, fpin, fpout, dodecode ? 0:1), *hct; if (iseof && !h) continue; /* Artifact */ hct=find_header(h, ct_s); /* ** If this is a multipart MIME section, we can keep on ** truckin'. ** */ if (hct) { struct mime_header *mh= parse_mime_header(hct->header+ (sizeof(ct_s)-1)); const char *bv; if (strcasecmp(mh->header_name, "multipart/x-mimegpg") == 0) { /* Punt */ char *buf=malloc(strlen(hct->header)+100); const char *p; if (!buf) { free_mime_header(mh); free_header(h); perror("malloc"); exit(1); } strcpy(buf, "Content-Type: multipart/mixed"); p=strchr(hct->header, ';'); strcat(buf, p ? p:""); free(hct->header); hct->header=buf; mh=parse_mime_header(hct->header+ sizeof(ct_s)-1); } if (strncasecmp(mh->header_name, "multipart/", 10)==0 && (bv=get_mime_attr(mh, "boundary")) != 0 && (doencode & ENCODE_ENCAPSULATE) == 0 ) { struct header *p; push_mimestack(&boundary_stack, bv); if (dodecode) { if (strcasecmp(mh->header_name, "multipart/signed")==0 && (dodecode & DECODE_CHECKSIGN) && isgpg(mh)) { print_noncontent_headers(h, fpout ); free_mime_header(mh); checksign(&boundary_stack, &iseof, h, fpin, fpout, argc, argv); free_header(h); continue; } if (strcasecmp(mh->header_name, "multipart/encrypted") ==0 && (dodecode & DECODE_UNENCRYPT) && isgpg(mh)) { print_noncontent_headers(h, fpout ); free_mime_header(mh); decrypt(&boundary_stack, &iseof, h, fpin, fpout, argc, argv); free_header(h); continue; } } for (p=h; p; p=p->next) { fprintf(fpout, "%s", p->header); } putc('\n', fpout); free_header(h); free_mime_header(mh); find_boundary(&boundary_stack, &iseof, fpin, fpout, dodecode ? 0:1); continue; } free_mime_header(mh); } if (dodecode) { struct header *p; int is_message_rfc822=0; for (p=h; p; p=p->next) { fprintf(fpout, "%s", p->header); } putc('\n', fpout); /* ** If this is a message/rfc822 attachment, we can ** resume reading the next set of headers. */ hct=find_header(h, ct_s); if (hct) { struct mime_header *mh= parse_mime_header(hct->header+ (sizeof(ct_s)-1)); if (strcasecmp(mh->header_name, "message/rfc822") == 0) is_message_rfc822=1; free_mime_header(mh); } free_header(h); if (!is_message_rfc822) find_boundary(&boundary_stack, &iseof, fpin, fpout, 0); continue; } if (doencode) dogpgencrypt(&boundary_stack, h, &iseof, fpin, fpout, argc, argv, dosign); else dogpgsign(&boundary_stack, h, &iseof, fpin, fpout, argc, argv); free_header(h); } if (ferror(fpout)) return (1); return (0); }
static struct header *read_headers(struct mimestack **stack, int *iseof, FILE *fpin, FILE *fpout, int doappend) { char buf[BUFSIZ]; struct read_header_context rhc; struct header *h; init_read_header_context(&rhc); while (!*iseof) { if (fgets(buf, sizeof(buf), fpin) == NULL) { *iseof=1; break; } if (READ_START_OF_LINE(rhc)) { struct mimestack *b; int is_closing; if (strcmp(buf, "\n") == 0 || strcmp(buf, "\r\n") == 0) break; b=is_boundary(*stack, buf, &is_closing); if (b) { /* ** Corrupted MIME message. We should NOT ** see a MIME boundary in the middle of the ** headers! ** ** Ignore this damage. */ struct header *p; h=finish_header(&rhc); for (p=h; p; p=p->next) fprintf(fpout, "%s", p->header); fprintf(fpout, "--%s%s", b->boundary, is_closing ? "--":""); if (is_closing) { pop_mimestack_to(stack, b); find_boundary(stack, iseof, fpin, fpout, doappend); } free_header(h); init_read_header_context(&rhc); continue; /* From the top */ } } read_header(&rhc, buf); } return (finish_header(&rhc)); }
static void decrypt(struct mimestack **stack, int *iseof, struct header *h, FILE *fpin, FILE *fpout, int argc, char **argv) { struct header *p, *q; char temp_file[TEMPNAMEBUFSIZE]; int temp_fd; FILE *temp_fp; struct mime_header *mh; int flag; temp_fd=mimegpg_tempfile(temp_file); if (temp_fd < 0 || (temp_fp=fdopen(temp_fd, "w+")) == 0) { if (temp_fd >= 0) close(temp_fd); perror("open"); exit(1); } for (p=h; p; p=p->next) { fprintf(temp_fp, "%s", p->header); } putc('\n', temp_fp); find_boundary(stack, iseof, fpin, temp_fp, 0); if (*iseof) { fclose(temp_fp); unlink(temp_file); return; } p=read_headers(stack, iseof, fpin, temp_fp, 0); if (*iseof) { free_header(p); fclose(temp_fp); unlink(temp_file); return; } q=find_header(p, "content-type:"); flag=0; if (q) { mh=parse_mime_header(q->header+13); if (!mh) { perror("malloc"); free_header(p); fclose(temp_fp); unlink(temp_file); exit(1); } if (strcasecmp(mh->header_name, "application/pgp-encrypted") == 0) flag=1; free_mime_header(mh); } for (q=p; q; q=q->next) { fprintf(temp_fp, "%s", q->header); } free_header(p); putc('\n', temp_fp); p=read_headers(stack, iseof, fpin, temp_fp, 0); if (*iseof) { free_header(p); fclose(temp_fp); unlink(temp_file); return; } q=find_header(p, "version:"); if (flag) { if (!q || atoi(p->header + 8) != 1) flag=0; } for (q=p; q; q=q->next) { fprintf(temp_fp, "%s", q->header); } free_header(p); putc('\n', temp_fp); find_boundary(stack, iseof, fpin, temp_fp, 0); if (*iseof) { fclose(temp_fp); unlink(temp_file); return; } p=read_headers(stack, iseof, fpin, temp_fp, 0); if (*iseof) { free_header(p); fclose(temp_fp); unlink(temp_file); return; } q=find_header(p, "content-type:"); if (q && flag) { flag=0; mh=parse_mime_header(q->header+13); if (!mh) { perror("malloc"); free_header(p); fclose(temp_fp); unlink(temp_file); exit(1); } if (strcasecmp(mh->header_name, "application/octet-stream") == 0) flag=1; free_mime_header(mh); q=find_header(p, "content-transfer-encoding:"); if (q && flag) { flag=0; mh=parse_mime_header(strchr(q->header, ':')+1); if (!mh) { perror("malloc"); free_header(p); fclose(temp_fp); unlink(temp_file); exit(1); } if (strcasecmp(mh->header_name, "7bit") == 0 || strcasecmp(mh->header_name, "8bit") == 0) flag=1; free_mime_header(mh); } } for (q=p; q; q=q->next) { fprintf(temp_fp, "%s", q->header); } free_header(p); putc('\n', temp_fp); if (fflush(temp_fp) || ferror(temp_fp) || my_rewind(temp_fp) < 0) { perror(temp_file); fclose(temp_fp); unlink(temp_file); exit(1); } if (!flag) { int c; while ((c=getc(temp_fp)) != EOF) { putc(c, fpout); } fclose(temp_fp); unlink(temp_file); close_mime(stack, iseof, fpin, fpout); return; } fclose(temp_fp); if ((temp_fp=fopen(temp_file, "w+")) == NULL) { perror(temp_file); unlink(temp_file); exit(1); } noexec(temp_fp); dodecrypt(stack, iseof, fpin, temp_fp, argc, argv, temp_file, fpout); fclose(temp_fp); unlink(temp_file); }
/***************************************************************************** * this function handles the direct memory access to the buffer * and copies objects to and from memory *****************************************************************************/ int dmarequest(const message_t *request, message_t **response_ptr) { unsigned int offset; /* int blockrequest = 0; */ int verbose = 0; /* these are used for blocking the read requests */ struct timeval tp; struct timespec ts; /* use a local variable for datasel (in GET_DAT) */ datasel_t datasel; /* these are for typecasting */ headerdef_t *headerdef; datadef_t *datadef; eventdef_t *eventdef; eventsel_t *eventsel; /* this will hold the response */ message_t *response; response = (message_t*)malloc(sizeof(message_t)); /* check for "out of memory" problems */ if (response == NULL) { *response_ptr = NULL; return -1; } response->def = (messagedef_t*)malloc(sizeof(messagedef_t)); /* check for "out of memory" problems */ if (response->def == NULL) { *response_ptr = NULL; free(response); return -1; } response->buf = NULL; /* the response should be passed to the calling function, where it should be freed */ *response_ptr = response; if (verbose>1) print_request(request->def); switch (request->def->command) { case PUT_HDR: if (verbose>1) fprintf(stderr, "dmarequest: PUT_HDR\n"); pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexdata); pthread_mutex_lock(&mutexevent); headerdef = (headerdef_t*)request->buf; if (verbose>1) print_headerdef(headerdef); /* delete the old header, data and events */ free_header(); free_data(); free_event(); /* store the header and re-initialize */ header = (header_t*)malloc(sizeof(header_t)); DIE_BAD_MALLOC(header); header->def = (headerdef_t*)malloc(sizeof(headerdef_t)); DIE_BAD_MALLOC(header->def); header->buf = malloc(headerdef->bufsize); DIE_BAD_MALLOC(header->buf); memcpy(header->def, request->buf, sizeof(headerdef_t)); memcpy(header->buf, (char*)request->buf+sizeof(headerdef_t), headerdef->bufsize); header->def->nsamples = 0; header->def->nevents = 0; init_data(); init_event(); response->def->version = VERSION; response->def->bufsize = 0; /* check whether memory could indeed be allocated */ if (data!= NULL && data->buf != NULL && data->def != NULL) { response->def->command = PUT_OK; } else { /* let's at least tell the client that something's wrong */ response->def->command = PUT_ERR; } pthread_mutex_unlock(&mutexevent); pthread_mutex_unlock(&mutexdata); pthread_mutex_unlock(&mutexheader); break; case PUT_DAT: if (verbose>1) fprintf(stderr, "dmarequest: PUT_DAT\n"); pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexdata); datadef = (datadef_t*)request->buf; if (verbose>1) print_datadef(datadef); if (verbose>2) print_buf(request->buf, request->def->bufsize); response->def->version = VERSION; response->def->bufsize = 0; if (request->def->bufsize < sizeof(datadef_t)) response->def->command = PUT_ERR; else if (header==NULL || data==NULL) response->def->command = PUT_ERR; else if (header->def->nchans != datadef->nchans) response->def->command = PUT_ERR; else if (header->def->data_type != datadef->data_type) response->def->command = PUT_ERR; else if (datadef->nsamples > current_max_num_sample) response->def->command = PUT_ERR; else { unsigned int i; unsigned int wordsize = wordsize_from_type(header->def->data_type); unsigned int datasize = wordsize * datadef->nsamples * datadef->nchans; response->def->command = PUT_OK; if (wordsize == 0) { fprintf(stderr, "dmarequest: unsupported data type (%d)\n", datadef->data_type); response->def->command = PUT_ERR; } else if (datasize > datadef->bufsize || (datadef->bufsize + sizeof(datadef_t)) > request->def->bufsize) { fprintf(stderr, "dmarequest: invalid size definitions in PUT_DAT request\n"); response->def->command = PUT_ERR; } else { /* record the time at which the data was received */ if (clock_gettime(CLOCK_REALTIME, &putdat_clock) != 0) { perror("clock_gettime"); return -1; } /* number of bytes per sample (all channels) is given by wordsize x number of channels */ unsigned int chansize = wordsize * data->def->nchans; /* request_data points to actual data samples within the request, use char* for convenience */ const char *request_data = (const char *) request->buf + sizeof(datadef_t); char *buffer_data = (char *)data->buf; for (i=0; i<datadef->nsamples; i++) { memcpy(buffer_data+(thissample*chansize), request_data+(i*chansize), chansize); header->def->nsamples++; thissample++; thissample = WRAP(thissample, current_max_num_sample); } /* Signal possibly waiting threads that we have received data */ pthread_cond_broadcast(&getData_cond); } } pthread_mutex_unlock(&mutexdata); pthread_mutex_unlock(&mutexheader); break; case PUT_EVT: if (verbose>1) fprintf(stderr, "dmarequest: PUT_EVT\n"); pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexevent); /* record the time at which the event was received */ if (clock_gettime(CLOCK_REALTIME, &putevt_clock) != 0) { perror("clock_gettime"); return -1; } /* Give an error message if there is no header, or if the given event array is defined badly */ if (header==NULL || event==NULL || check_event_array(request->def->bufsize, request->buf) < 0) { response->def->version = VERSION; response->def->command = PUT_ERR; response->def->bufsize = 0; } else { /* go over all events and store them one by one */ response->def->version = VERSION; response->def->command = PUT_OK; response->def->bufsize = 0; offset = 0; /* this represents the offset of the event in the buffer */ while (offset<request->def->bufsize) { FREE(event[thisevent].def); FREE(event[thisevent].buf); eventdef = (eventdef_t*)((char*)request->buf+offset); if (verbose>1) print_eventdef(eventdef); event[thisevent].def = (eventdef_t*)malloc(sizeof(eventdef_t)); DIE_BAD_MALLOC(event[thisevent].def); memcpy(event[thisevent].def, (char*)request->buf+offset, sizeof(eventdef_t)); if (event[thisevent].def->sample == EVENT_AUTO_SAMPLE) { /* automatically convert event->def->sample to current sample number */ /* make some fine adjustment of the assigned sample number */ double adjust = (putevt_clock.tv_sec - putdat_clock.tv_sec) + (double)(putevt_clock.tv_nsec - putdat_clock.tv_nsec) / 1000000000L; event[thisevent].def->sample = header->def->nsamples + (int)(header->def->fsample*adjust); } offset += sizeof(eventdef_t); event[thisevent].buf = malloc(eventdef->bufsize); DIE_BAD_MALLOC(event[thisevent].buf); memcpy(event[thisevent].buf, (char*)request->buf+offset, eventdef->bufsize); offset += eventdef->bufsize; if (verbose>1) print_eventdef(event[thisevent].def); thisevent++; thisevent = WRAP(thisevent, MAXNUMEVENT); header->def->nevents++; } } pthread_mutex_unlock(&mutexevent); pthread_mutex_unlock(&mutexheader); break; case GET_HDR: if (verbose>1) fprintf(stderr, "dmarequest: GET_HDR\n"); if (header==NULL) { response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; break; } pthread_mutex_lock(&mutexheader); response->def->version = VERSION; response->def->command = GET_OK; response->def->bufsize = 0; response->def->bufsize = append(&response->buf, response->def->bufsize, header->def, sizeof(headerdef_t)); response->def->bufsize = append(&response->buf, response->def->bufsize, header->buf, header->def->bufsize); pthread_mutex_unlock(&mutexheader); break; case GET_DAT: if (verbose>1) fprintf(stderr, "dmarequest: GET_DAT\n"); if (header==NULL || data==NULL) { response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; break; } pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexdata); if (request->def->bufsize) { /* the selection has been specified */ memcpy(&datasel, request->buf, sizeof(datasel_t)); /* If endsample is -1 read the buffer to the end */ if(datasel.endsample == -1) { datasel.endsample = header->def->nsamples - 1; } } else { /* determine a valid selection */ if (header->def->nsamples>current_max_num_sample) { /* the ringbuffer is completely full */ datasel.begsample = header->def->nsamples - current_max_num_sample; datasel.endsample = header->def->nsamples - 1; } else { /* the ringbuffer is not yet completely full */ datasel.begsample = 0; datasel.endsample = header->def->nsamples - 1; } } /* // if the read should block... if(blockrequest == 1) { // check whether data is available while((datasel.begsample >= (datasel.endsample+1)) || (datasel.endsample > header->def->nsamples - 1)) { // if not unlock all mutexes pthread_mutex_unlock(&mutexdata); pthread_mutex_unlock(&mutexheader); // wait for the condition to be signaled pthread_mutex_lock(&getData_mutex); gettimeofday(&tp, NULL); ts.tv_sec = tp.tv_sec; ts.tv_nsec = tp.tv_usec * 1000; ts.tv_sec += 1; pthread_cond_timedwait(&getData_cond, &getData_mutex, &ts); pthread_mutex_unlock(&getData_mutex); // Lock the mutexes again pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexdata); if(datasel.begsample == (datasel.endsample+1)) datasel.endsample = header->def->nsamples - 1; } } */ if (verbose>1) print_headerdef(header->def); if (verbose>1) print_datasel(&datasel); if (datasel.begsample < 0 || datasel.endsample < 0) { fprintf(stderr, "dmarequest: err1\n"); response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; } else if (datasel.begsample >= header->def->nsamples || datasel.endsample >= header->def->nsamples) { fprintf(stderr, "dmarequest: err2\n"); response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; } else if ((header->def->nsamples - datasel.begsample) > current_max_num_sample) { fprintf(stderr, "dmarequest: err3\n"); response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; } else { unsigned int wordsize = wordsize_from_type(data->def->data_type); if (wordsize==0) { fprintf(stderr, "dmarequest: unsupported data type (%d)\n", data->def->data_type); response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; } else { unsigned int n; response->def->version = VERSION; response->def->command = GET_OK; response->def->bufsize = 0; /* determine the number of samples to return */ n = datasel.endsample - datasel.begsample + 1; response->buf = malloc(sizeof(datadef_t) + n*data->def->nchans*wordsize); if (response->buf == NULL) { /* not enough space for copying data into response */ fprintf(stderr, "dmarequest: out of memory\n"); response->def->command = GET_ERR; } else { /* number of bytes per sample (all channels) */ unsigned int chansize = data->def->nchans * wordsize; /* convenience pointer to start of actual data in response */ char *resp_data = ((char *) response->buf) + sizeof(datadef_t); /* this is the location of begsample within the ringbuffer */ unsigned int start_index = WRAP(datasel.begsample, current_max_num_sample); /* have datadef point into the freshly allocated response buffer and directly fill in the information */ datadef = (datadef_t *) response->buf; datadef->nchans = data->def->nchans; datadef->data_type = data->def->data_type; datadef->nsamples = n; datadef->bufsize = n*chansize; response->def->bufsize = sizeof(datadef_t) + datadef->bufsize; if (start_index + n <= current_max_num_sample) { /* we can copy everything in one go */ memcpy(resp_data, (char*)(data->buf) + start_index*chansize, n*chansize); } else { /* need to wrap around at current_max_num_sample */ unsigned int na = current_max_num_sample - start_index; unsigned int nb = n - na; memcpy(resp_data, (char*)(data->buf) + start_index*chansize, na*chansize); memcpy(resp_data + na*chansize, (char*)(data->buf), nb*chansize); /* printf("Wrapped around!\n"); */ } } } } pthread_mutex_unlock(&mutexdata); pthread_mutex_unlock(&mutexheader); break; case GET_EVT: if (verbose>1) fprintf(stderr, "dmarequest: GET_EVT\n"); if (header==NULL || event==NULL || header->def->nevents==0) { response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; break; } pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexevent); eventsel = (eventsel_t*)malloc(sizeof(eventsel_t)); DIE_BAD_MALLOC(eventsel); /* determine the selection */ if (request->def->bufsize) { /* the selection has been specified */ memcpy(eventsel, request->buf, sizeof(eventsel_t)); } else { /* determine a valid selection */ if (header->def->nevents>MAXNUMEVENT) { /* the ringbuffer is completely full */ eventsel->begevent = header->def->nevents - MAXNUMEVENT; eventsel->endevent = header->def->nevents - 1; } else { /* the ringbuffer is not yet completely full */ eventsel->begevent = 0; eventsel->endevent = header->def->nevents - 1; } } if (verbose>1) print_headerdef(header->def); if (verbose>1) print_eventsel(eventsel); if (eventsel==NULL) { response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; } else if (eventsel->begevent < 0 || eventsel->endevent < 0) { fprintf(stderr, "dmarequest: err1\n"); response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; } else if (eventsel->begevent >= header->def->nevents || eventsel->endevent >= header->def->nevents) { fprintf(stderr, "dmarequest: err2\n"); response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; } else if ((header->def->nevents-eventsel->begevent) > MAXNUMEVENT) { fprintf(stderr, "dmarequest: err3\n"); response->def->version = VERSION; response->def->command = GET_ERR; response->def->bufsize = 0; } else { unsigned int j,n; response->def->version = VERSION; response->def->command = GET_OK; response->def->bufsize = 0; /* determine the number of events to return */ n = eventsel->endevent - eventsel->begevent + 1; for (j=0; j<n; j++) { if (verbose>1) print_eventdef(event[WRAP(eventsel->begevent+j, MAXNUMEVENT)].def); response->def->bufsize = append(&response->buf, response->def->bufsize, event[WRAP(eventsel->begevent+j, MAXNUMEVENT)].def, sizeof(eventdef_t)); response->def->bufsize = append(&response->buf, response->def->bufsize, event[WRAP(eventsel->begevent+j, MAXNUMEVENT)].buf, event[WRAP(eventsel->begevent+j, MAXNUMEVENT)].def->bufsize); } } FREE(eventsel); pthread_mutex_unlock(&mutexevent); pthread_mutex_unlock(&mutexheader); break; case FLUSH_HDR: pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexdata); pthread_mutex_lock(&mutexevent); if (header) { free_header(); free_data(); free_event(); response->def->version = VERSION; response->def->command = FLUSH_OK; response->def->bufsize = 0; } else { response->def->version = VERSION; response->def->command = FLUSH_ERR; response->def->bufsize = 0; } pthread_mutex_unlock(&mutexevent); pthread_mutex_unlock(&mutexdata); pthread_mutex_unlock(&mutexheader); break; case FLUSH_DAT: pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexdata); if (header && data) { header->def->nsamples = thissample = 0; response->def->version = VERSION; response->def->command = FLUSH_OK; response->def->bufsize = 0; } else { response->def->version = VERSION; response->def->command = FLUSH_ERR; response->def->bufsize = 0; } pthread_mutex_unlock(&mutexdata); pthread_mutex_unlock(&mutexheader); break; case FLUSH_EVT: pthread_mutex_lock(&mutexheader); pthread_mutex_lock(&mutexevent); if (header && event) { unsigned int i; header->def->nevents = thisevent = 0; for (i=0; i<MAXNUMEVENT; i++) { FREE(event[i].def); FREE(event[i].buf); } response->def->version = VERSION; response->def->command = FLUSH_OK; response->def->bufsize = 0; } else { response->def->version = VERSION; response->def->command = FLUSH_ERR; response->def->bufsize = 0; } pthread_mutex_unlock(&mutexevent); pthread_mutex_unlock(&mutexheader); break; case WAIT_DAT: /* SK: This request means that the client wants to wait until MORE than waitdef_t.threshold.nsamples samples OR MORE THAN waitdef_t.threshold.nevents events are in the buffer, BUT only for the time given in waitdef_t.milliseconds. The response is just the number of samples and events in the buffer as described by samples_events_t. */ response->def->version = VERSION; if (header==NULL || request->def->bufsize!=sizeof(waitdef_t)) { response->def->command = WAIT_ERR; response->def->bufsize = 0; } else { int waiterr; waitdef_t *wd = (waitdef_t *) request->buf; samples_events_t *nret = malloc(sizeof(samples_events_t)); UINT32_T nsmp, nevt; if (nret == NULL) { /* highly unlikely, but we cannot allocate a sample_event_t - return an error */ response->def->command = WAIT_ERR; response->def->bufsize = 0; break; } /* Let response->buf point to the new sample_event_t structure */ response->def->command = WAIT_OK; response->def->bufsize = sizeof(samples_events_t); response->buf = nret; /* get current number of samples */ pthread_mutex_lock(&mutexheader); nsmp = header->def->nsamples; nevt = header->def->nevents; pthread_mutex_unlock(&mutexheader); if (wd->milliseconds == 0 || nsmp > wd->threshold.nsamples || nevt > wd->threshold.nevents) { /* the client doesn't want to wait, or we're already above the threshold: return immediately */ nret->nsamples = nsmp; nret->nevents = nevt; break; } gettimeofday(&tp, NULL); ts.tv_sec = tp.tv_sec + (wd->milliseconds/1000); ts.tv_nsec = 1000 * (tp.tv_usec + (wd->milliseconds % 1000)*1000); while (ts.tv_nsec >= 1000000000) { ts.tv_sec++; ts.tv_nsec-=1000000000; } /* FIXME: The getData condition variable is only triggered by incoming data, not events */ do { pthread_mutex_lock(&getData_mutex); waiterr = pthread_cond_timedwait(&getData_cond, &getData_mutex, &ts); pthread_mutex_unlock(&getData_mutex); /* get current number of samples */ pthread_mutex_lock(&mutexheader); nsmp = header->def->nsamples; nevt = header->def->nevents; pthread_mutex_unlock(&mutexheader); } while (nsmp <= wd->threshold.nsamples && nevt <= wd->threshold.nevents && waiterr==0); nret->nsamples = nsmp; nret->nevents = nevt; } break; default: fprintf(stderr, "dmarequest: unknown command\n"); } if (verbose>0) fprintf(stderr, "dmarequest: thissample = %u, thisevent = %u\n", thissample, thisevent); /* everything went fine */ return 0; }
int headers_complete_cb(http_parser *p) { VALUE obj, key; client_t *client = get_client(p); request *req = client->req; VALUE env = client->environ; uint32_t i = 0; header *h; if(max_content_length < p->content_length){ client->bad_request_code = 413; return -1; } if (p->http_minor == 1) { obj = rb_str_new2("HTTP/1.1"); } else { obj = rb_str_new2("HTTP/1.0"); } rb_hash_aset(env, server_protocol, obj); if(req->path){ obj = getRbString(req->path); rb_hash_aset(env, path_info, obj); req->path = NULL; } if(req->uri){ obj = getRbString(req->uri); rb_hash_aset(env, request_uri, obj); req->uri = NULL; } if(req->query_string){ obj = getRbString(req->query_string); rb_hash_aset(env, query_string, obj); req->query_string = NULL; } if(req->fragment){ obj = getRbString(req->fragment); rb_hash_aset(env, http_fragment, obj); req->fragment = NULL; } for(i = 0; i < req->num_headers+1; i++){ h = req->headers[i]; if(h){ key = getRbString(h->field); obj = getRbString(h->value); rb_hash_aset(env, key, obj); free_header(h); req->headers[i] = NULL; } } switch(p->method){ case HTTP_DELETE: obj = rb_str_new("DELETE", 6); break; case HTTP_GET: obj = rb_str_new("GET", 3); break; case HTTP_HEAD: obj = rb_str_new("HEAD", 4); break; case HTTP_POST: obj = rb_str_new("POST", 4); break; case HTTP_PUT: obj = rb_str_new("PUT", 3); break; case HTTP_CONNECT: obj = rb_str_new("CONNECT", 7); break; case HTTP_OPTIONS: obj = rb_str_new("OPTIONS", 7); break; case HTTP_TRACE: obj = rb_str_new("TRACE", 5); break; case HTTP_COPY: obj = rb_str_new("COPY", 4); break; case HTTP_LOCK: obj = rb_str_new("LOCK", 4); break; case HTTP_MKCOL: obj = rb_str_new("MKCOL", 5); break; case HTTP_MOVE: obj = rb_str_new("MOVE", 4); break; case HTTP_PROPFIND: obj = rb_str_new("PROPFIND", 8); break; case HTTP_PROPPATCH: obj = rb_str_new("PROPPATCH", 9); break; case HTTP_UNLOCK: obj = rb_str_new("UNLOCK", 6); break; case HTTP_REPORT: obj = rb_str_new("REPORT", 6); break; case HTTP_MKACTIVITY: obj = rb_str_new("MKACTIVITY", 10); break; case HTTP_CHECKOUT: obj = rb_str_new("CHECKOUT", 8); break; case HTTP_MERGE: obj = rb_str_new("MERGE", 5); break; default: obj = rb_str_new("GET", 3); break; } rb_hash_aset(env, request_method, obj); ruby_xfree(req); client->req = NULL; client->body_length = p->content_length; return 0; }
static GwyContainer* burleigh_exp_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL; gchar *buffer = NULL; BurleighExpHeader header; gsize size = 0; GError *err = NULL; GwyDataField *dfield; gdouble *data; guint i, n; if (!g_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < MIN_FILE_SIZE + 2) { err_TOO_SHORT(error); g_free(buffer); return NULL; } if (!burleigh_exp_read_header(&header, buffer, error)) goto fail; n = header.xres * header.yres; if (header.binary) { if (header.bpp != 16) { err_BPP(error, header.bpp); goto fail; } else if (err_SIZE_MISMATCH(error, header.length + 2*n, size, TRUE)) goto fail; } dfield = gwy_data_field_new(header.xres, header.yres, header.xscale, header.yscale, FALSE); data = gwy_data_field_get_data(dfield); if (header.binary) { const gint16 *d16 = (const gint16*)(buffer + header.length); for (i = 0; i < n; i++) data[i] = GINT16_FROM_LE(d16[i]); } else { gchar *p = buffer + header.length; for (i = 0; i < n; i++) data[i] = strtol(p, &p, 10); } gwy_data_field_multiply(dfield, header.zscale/32768.0); /* Units references released in free_header() */ gwy_data_field_set_si_unit_xy(dfield, header.xyunits); gwy_data_field_set_si_unit_z(dfield, header.zunits); container = gwy_container_new(); gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield); g_object_unref(dfield); gwy_app_channel_title_fall_back(container, 0); gwy_file_channel_import_log_add(container, 0, NULL, filename); fail: free_header(&header); g_free(buffer); return container; }
int batch_mail(int conn, char *command) { char instance[63] = ""; int business = 0; row_t *rows = NULL; row_t *row = NULL; row_t *rr = NULL; int rowc; int count = 0; int flags = 0; char *sql; char *email = NULL; char *file; char *filename; char *tmp = NULL; smtp_recipient_t *r = NULL; smtp_header_t *h = NULL; smtp_attach_t *a = NULL; if (sscanf(command, "MAIL %[^.].%i\n", instance, &business) != 2) { chat(conn, "ERROR: Invalid syntax\n"); return 0; } chat(conn, "Sending email batch for instance '%s', business '%i' ... ", instance, business); db_connect(config->dbs); /* verify instance and business exist */ asprintf(&sql, "SELECT * FROM instance WHERE id='%s';", instance); rowc = batch_fetch_rows(NULL, 0, sql, &rows); free(sql); if (rowc == 0) { chat(conn, "ERROR: instance '%s' does not exist\n", instance); db_disconnect(config->dbs); return 0; } rows = NULL; asprintf(&sql, "SELECT * FROM business WHERE id='%i';", business); rowc = batch_fetch_rows(instance, 0, sql, &rows); free(sql); if (rowc == 0) { chat(conn, "ERROR: business '%s.%i' does not exist\n", instance, business); db_disconnect(config->dbs); return 0; } rows = NULL; chat(conn, CLERK_RESP_OK); /* lock emaildetail table */ batch_exec_sql(instance, business, "BEGIN WORK; LOCK TABLE emaildetail IN EXCLUSIVE MODE"); /* fetch emails to send */ rowc = batch_fetch_rows(instance, business, "SELECT * FROM email_unsent", &rows); row = rows; while (row != NULL) { /* get id of email */ email = db_field(row, "email")->fvalue; if (email == NULL) continue; /* loop through recipients */ asprintf(&sql, "SELECT * FROM emailrecipient WHERE email=%s", email); rowc = batch_fetch_rows(instance, business, sql, &rr); free(sql); if (rowc == 0) { /* skip email with no recipients */ syslog(LOG_DEBUG, "Skipping email with no recipients"); row = row->next; continue; } flags = 0; while (rr != NULL) { if (strcmp(db_field(rr, "is_to")->fvalue, "t") == 0) flags += EMAIL_TO; if (strcmp(db_field(rr, "is_cc")->fvalue, "t") == 0) flags += EMAIL_CC; add_recipient(&r, "", db_field(rr, "emailaddress")->fvalue, flags); rr = rr->next; } /* loop through headers */ asprintf(&sql, "SELECT * FROM emailheader WHERE email=%s", email); rowc = batch_fetch_rows(instance, business, sql, &rr); free(sql); while (rr != NULL) { add_header(&h, db_field(rr, "header")->fvalue, db_field(rr, "value")->fvalue); rr = rr->next; } /* loop through attachments */ asprintf(&sql, "SELECT * FROM emailpart WHERE email=%s", email); rowc = batch_fetch_rows(instance, business, sql, &rr); free(sql); while (rr != NULL) { file = db_field(rr, "file")->fvalue; tmp = strdup(file); filename = basename(tmp); add_attach(&a, file, filename); free(tmp); rr = rr->next; } /* send email */ /* FIXME: this will quietly crash if db_field returns NULL */ if (send_email( db_field(row, "sendername")->fvalue, db_field(row, "sendermail")->fvalue, db_field(row, "body")->fvalue, r, h, a) == 0) { /* update email with sent time */ asprintf(&sql, "SELECT email_sent(%s);", email); chat(conn, "sql: %s\n", sql); batch_exec_sql(instance, business, sql); free(sql); count++; } free_recipient(r); r = NULL; free_header(h); h = NULL; free_attach(a); a = NULL; row = row->next; } /* commit changes and unlock emaildetail table */ batch_exec_sql(instance, business, "COMMIT WORK;"); db_disconnect(config->dbs); chat(conn, "%i/%i emails sent\n", count, rowc); return 0; }