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;
}
