void store_rel_data()
{
clear_data_buffer();
if (data_available == TRUE) {
strcat(data_buffer, time_stmp_str);
strcat(data_buffer, comma);
strcat(data_buffer, chem);
strcat(data_buffer, comma);
strcat(data_buffer, abs_str);
strcat(data_buffer, comma);
strcat(data_buffer, coeff_str);
strcat(data_buffer, comma);
strcat(data_buffer, real_str);
if (nv_report_mode == 4) fprintf(COM_A, "%s\r\n", data_buffer);
if(sd_status==0){
buffer_select = 0;
heartbeat(FALSE);
append_data(file_ptr_rel_all);
heartbeat(TRUE);
heartbeat(FALSE);
append_data(file_ptr_rel_new);
heartbeat(TRUE);
}
}
}
/*!
Merges the second buffer with the first. If \a after is \c true, the
second buffer's contents will be appended to the first ones, else they
will be prepended.
The second buffer will be freed if this function succeeds.
*/
static status_t
merge_buffer(net_buffer *_buffer, net_buffer *_with, bool after)
{
net_buffer_private *buffer = (net_buffer_private *)_buffer;
net_buffer_private *with = (net_buffer_private *)_with;
if (with == NULL)
return B_BAD_VALUE;
if (after) {
// the simple case: just append the second buffer
status_t error = append_data(buffer, with->data, with->size);
if (error != B_OK)
return error;
} else {
// append buffer to the second buffer, then switch the data
status_t error = append_data(with, buffer->data, buffer->size);
if (error != B_OK)
return error;
free(buffer->data);
buffer->data = with->data;
buffer->size = with->size;
with->data = NULL;
}
free_buffer(with);
return B_OK;
}
void store_aws_data(int8 macro, int16 mmacro_var)
{
char comma[2] = {',' , '\0'};
char endofline[3] = {'\r' , '\n' , '\0'};
char config_str[30];
clear_data_buffer();
time_stamp();
strcat(data_buffer, time_stmp_str);
strcat(data_buffer, comma);
sprintf(config_str, "%u,%Lu",macro,mmacro_var);
strcat(data_buffer, config_str);
strcat(data_buffer, endofline);
if (nv_report_mode == 4) fprintf(COM_A, "%s\r\n", data_buffer);
if(sd_status==0){
buffer_select = 0;
heartbeat(FALSE);
append_data(file_ptr_raw_all);
heartbeat(TRUE);
heartbeat(FALSE);
append_data(file_ptr_raw_new);
heartbeat(TRUE);
}
}
void store_wms_data(int8 macro)
{
char comma[2] = {',' , '\0'};
char endofline[3] = {'\r' , '\n' , '\0'};
char config_str[30];
clear_data_buffer();
time_stamp();
strcat(data_buffer, time_stmp_str);
strcat(data_buffer, comma);
sprintf(config_str, "%u,%Lu,%Lu,%Lu,%Lu,%Lu,%Lu,%Ld",
macro,nv_macro_mode, nv_interval, nv_volume, nv_port, nv_sample,
e_target_port[0],m_lin_pos[1]); // changed from e_port[0]
strcat(data_buffer, config_str);
strcat(data_buffer, endofline);
fprintf(COM_A, "%s\r\n", data_buffer);
if(sd_status==0){
buffer_select = 0;
heartbeat(FALSE);
append_data(file_ptr_raw_all);
heartbeat(TRUE);
heartbeat(FALSE);
append_data(file_ptr_raw_new);
heartbeat(TRUE);
}
}
int bootstage_stash(void *base, int size)
{
struct bootstage_hdr *hdr = (struct bootstage_hdr *)base;
struct bootstage_record *rec;
char buf[20];
char *ptr = base, *end = ptr + size;
uint32_t count;
int id;
if (hdr + 1 > (struct bootstage_hdr *)end) {
debug("%s: Not enough space for bootstage hdr\n", __func__);
return -1;
}
/* Write an arbitrary version number */
hdr->version = BOOTSTAGE_VERSION;
/* Count the number of records, and write that value first */
for (rec = record, id = count = 0; id < BOOTSTAGE_ID_COUNT;
id++, rec++) {
if (rec->time_us != 0)
count++;
}
hdr->count = count;
hdr->size = 0;
hdr->magic = BOOTSTAGE_MAGIC;
ptr += sizeof(*hdr);
/* Write the records, silently stopping when we run out of space */
for (rec = record, id = 0; id < BOOTSTAGE_ID_COUNT; id++, rec++) {
if (rec->time_us != 0)
append_data(&ptr, end, rec, sizeof(*rec));
}
/* Write the name strings */
for (rec = record, id = 0; id < BOOTSTAGE_ID_COUNT; id++, rec++) {
if (rec->time_us != 0) {
const char *name;
name = get_record_name(buf, sizeof(buf), rec);
append_data(&ptr, end, name, strlen(name) + 1);
}
}
/* Check for buffer overflow */
if (ptr > end) {
debug("%s: Not enough space for bootstage stash\n", __func__);
return -1;
}
/* Update total data size */
hdr->size = ptr - (char *)base;
printf("Stashed %d records\n", hdr->count);
return 0;
}
int16 probe_read(int8 store, int8 display){
// get detector reading and write to a file on the SD card
// the string to be stored is compiled into "data_buffer"
// first the data_buffer is cleared
// then time_stamp_str, flags, results & end-of-line are concatenated
// append_data writes "data_buffer" to the file "all" and "new" files
char comma[2] = {',' , '\0'};
char endofline[3] = {'\r' , '\n' , '\0'};
char tempstr[4] = {'T','m','p','\0'};
int16 temp = 0;
clear_slave_reply();
clear_data_buffer();
time_stamp();
strcat(data_buffer, time_stmp_str);
strcat(data_buffer, comma);
strcat(data_buffer, tempstr);
strcat(data_buffer, comma);
//*** READ TEMP PROBE ***//
temp=temp_probe();
//*** PUT INTO slave_reply ***//
//itoa(temp,10,slave_reply);
sprintf (slave_reply, "%05.3w",temp);
strcat(slave_reply, endofline);
strcat(data_buffer, slave_reply);
if (nv_report_mode == 0 && display == TRUE) fprintf(COM_A, "%s", data_buffer);
else if (nv_report_mode >= 4) fprintf(COM_A, "%s", data_buffer);
if (store == TRUE && sd_status==0) {
buffer_select = 0;
heartbeat(FALSE);
append_data(file_ptr_raw_all);
heartbeat(TRUE);
heartbeat(FALSE);
append_data(file_ptr_raw_new);
heartbeat(TRUE);
}
macro_flag = 900;
return (temp);
}
void run_code_event(struct state *state, struct event *event,
const char *text)
{
DEBUGP("%d: run code event\n", event->line_number);
char *error = NULL;
/* Wait for the right time before firing off this event. */
wait_for_event(state);
//TODO modify to support multi socket support
/*
* Idea: extend event struct to put a socked_fd and get this fd from
* the script (thus specified by user)?
*
*/
if (state->socket_under_test == NULL) {
asprintf(&error, "no socket to use for code");
goto error_out;
}
int fd = state->socket_under_test->live.fd;
struct code_state *code = state->code;
void *data = NULL;
int data_len = 0;
if (code->data_type == DATA_NONE) {
/* First time: try various getsockopt calls until one works. */
#if HAVE_TCP_INFO
if (data == NULL) {
code->data_type = DATA_TCP_INFO;
data = get_data(fd, code->data_type, &data_len);
}
#endif /* HAVE_TCP_INFO */
if (data == NULL) {
asprintf(&error,
"can't find getsockopt to get TCP info");
goto error_out;
}
} else {
/* Run the getsockopt we already picked above. */
data = get_data(fd, code->data_type, &data_len);
if (!data) {
asprintf(&error, "can't get info for socket");
goto error_out;
}
}
assert(code->data_type != DATA_NONE);
assert(data != NULL);
append_data(code, code->data_type, data, data_len);
append_text(code, state->config->script_path, event->line_number,
strdup(text));
return;
error_out:
die("%s:%d: runtime error in code: %s\n",
state->config->script_path, event->line_number, error);
free(error);
}
int main(int argc, char **argv)
{
assert(argc == 3);
char *result[2];
result[0] = "PASS";
result[1] = "FAILED";
printf("TEST CASE 0:%s\n", result[test_case_0(argv, 2)]);
//generate data
//can contact to single datanode
generate_data("local_file", 1024);
printf("TEST CASE 1:%s\n", result[test_case_1(argv, 1)]);
printf("TEST CASE 2:%s\n", result[test_case_2(argv, 0)]);
//can contact to two datanodes
generate_data("local_file_medium", 4096);
printf("TEST CASE 3:%s\n", result[test_case_3(argv, 1)]);
printf("TEST CASE 4:%s\n", result[test_case_4(argv, 0)]);
//can handle chunk pieces
generate_data("local_file_large", 8192);
printf("TEST CASE 5:%s\n", result[test_case_5(argv, 1)]);
printf("TEST CASE 6:%s\n", result[test_case_6(argv, 0)]);
//check every file is stored correctly
printf("TEST CASE 7:%s\n", result[test_case_7(argv)]);
//modify the file
append_data("local_file", 1024);
printf("TEST CASE 8:%s\n", result[test_case_8(argv, 3)]);
return 0;
}
static void
load_model_data (SortFlowState *state)
{
int start;
int end;
int index;
int i;
int limit = gnm_conf_get_core_sort_dialog_max_initial_clauses ();
if (state->is_cols) {
start = state->sel->v_range.cell.a.col;
end = state->sel->v_range.cell.b.col;
index = state->sel->v_range.cell.a.row;
} else {
start = state->sel->v_range.cell.a.row;
end = state->sel->v_range.cell.b.row;
index = state->sel->v_range.cell.a.col;
}
gtk_list_store_clear (state->model);
state->sort_items = 0;
if (end >= start + limit)
end = start + limit - 1;
for (i = start; i <= end; i++)
append_data (state, i, index);
}
void display_rec(int8 store, int8 display)
{
if (nv_report_mode == 0 && display == TRUE) fprintf(COM_A, "%s", data_buffer);
else if (nv_report_mode >= 4) fprintf(COM_A, "%s", data_buffer);
if (store==TRUE && sd_status==0) {
buffer_select = 0;
heartbeat(FALSE); // restarts WD & stops timer = 4 seconds to complete
append_data(file_ptr_raw_all);
heartbeat(TRUE);
heartbeat(FALSE); // restarts WD & stops timer = 4 seconds to complete
append_data(file_ptr_raw_new);
heartbeat(TRUE);
}
}
static void
cb_sort_field_selection(GtkWidget *item, AddSortFieldMenuState *menu_state)
{
append_data(menu_state->state,
menu_state->start,
menu_state->index);
/* Update sensitivity if this is the first sort item. */
if (menu_state->state->sort_items == 1)
set_button_sensitivity(menu_state->state);
}
struct TAPE_BLOCKS *flushrecs( struct RECS *recs,
int *recl,
int *recc,
size_t *filesz,
unsigned char pad )
{
struct TAPE_BLOCKS *blks;
int residual;
if(recs->filesz==0)
{
append_data(recs->blocks,&pad,1);
recs->filesz=1;
if(recs->recfm=='V')
{
recs->reccount=1;
recs->reclen=1;
}
}
if(recs->recfm=='F')
{
residual=recs->reclen-recs->filesz%recs->reclen;
residual=residual%recs->reclen;
if(residual)
{
unsigned char *padbfr;
recs->filesz+=residual;
padbfr=malloc(residual);
memset(padbfr,pad,residual);
append_data(recs->blocks,padbfr,residual);
free(padbfr);
}
recs->reccount=(int)recs->filesz/recs->reclen;
}
*recc=recs->reccount;
*recl=recs->reclen;
*filesz=recs->filesz;
blks=recs->blocks;
free(recs);
return blks;
}
bool bin_index_t::file_node::set(const data_t& key,const data_t& val)
{
validate_key_len(key);
open_index_file();
if(!root_page)
{
root_page=create_page();
append_page(*root_page);
save_index_data(0,root_page->page_offset);
add_page(root_page);
}
index_t it;
align_key(key,it);
if(get_item(it))
{
index_t old_i=it;
if(it.data_len>=val.size())save_data(it.data_offset,val);
else it.data_offset=append_data(val);
it.data_len=val.size();
if(old_i.data_offset==it.data_offset&&
old_i.data_len==it.data_len)
return false;
update_page(it);
return false;
}
index_t v;
v.key=key;
align_key(key,v);
v.data_len=val.size();
v.data_offset=append_data(val);
add_item(v);
return true;
}
/* and to the related tape block collection ù */
void addrecs(struct RECS *recs,unsigned char *bfr,int sz)
{
unsigned char recd[2];
recs->filesz+=sz;
switch(recs->recfm)
{
case 'V':
recd[1]=sz&0xff;
recd[0]=(sz>>8)&0xff;
append_data(recs->blocks,recd,2);
append_data(recs->blocks,bfr,sz);
recs->reccount++;
recs->reclen=MAX(recs->reclen,sz);
break;
case 'F':
append_data(recs->blocks,bfr,sz);
break;
}
}
int jester::parse_options(int argc, char *argv[])
{
static const struct option longopts[] = {{"method", required_argument, NULL, 'm'},
{"uri", required_argument, NULL, 'u'},
{"data", required_argument, NULL, 'd'},
{"interactive", no_argument, NULL, 'i'},
{"content", required_argument, NULL, 'c'},
{"header", required_argument, NULL, 'h'},
{NULL, 0, NULL, 0}};
int opt;
std::shared_ptr<jest::arg_pair> pair;
while ((opt = getopt_long(argc, argv, "u:m:d:ih:", longopts, NULL)) != -1) {
switch (opt) {
case 'u':
set_uri(optarg);
break;
case 'm':
if (!set_method(optarg)) {
printf("Unknown HTTP method %s\n", optarg);
return EXIT_FAILURE;
}
break;
case 'd':
pair = jest::split_arg(optarg, "=");
if (!pair) {
printf("Data should be in key=value format.");
return EXIT_FAILURE;
}
append_data(*pair);
break;
case 'c':
set_content(optarg);
break;
case 'i':
set_interactive(true);
break;
case 'h':
pair = jest::split_arg(optarg, ":");
if (!pair) {
printf("header should be in key:value format.");
return EXIT_FAILURE;
}
append_header(*pair);
break;
default:
syntax(argv[0]);
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
void record_event()
{
if(sd_status==0){
strcopy(event_buffer,"");
time_stamp();
strcat(event_buffer, time_stmp_str);
strcat(event_buffer, event_str);
buffer_select = 1;
heartbeat(FALSE);
append_data(file_ptr_events);
heartbeat(TRUE);
}
}
int main(void)
{
struct Node *n1;
struct Node *n2;
n1 = new_node(1);
n2 = new_node(2);
append_data(n2, 1, "This is n1's secret data");
append_data(n1, 2, "This is n2's secret data");
register_node(n1);
register_node(n2);
printf("n1's data: %s\n", server_get_data(n1));
printf("n2's data: %s\n", server_get_data(n2));
free_node(n1);
free_node(n2);
free_server();
return 0;
}
/*!
Appends data coming from buffer \a source to the buffer \a buffer. It only
clones the data, though, that is the data is not copied, just referenced.
*/
static status_t
append_cloned_data(net_buffer *_buffer, net_buffer *_source, uint32 offset,
size_t bytes)
{
if (bytes == 0)
return B_OK;
net_buffer_private *buffer = (net_buffer_private *)_buffer;
net_buffer_private *source = (net_buffer_private *)_source;
if (offset + bytes > source->size)
return B_BAD_VALUE;
return append_data(buffer, source->data + offset, bytes);
}
void prompt_to_packet(pamc_bp_t prompt, struct internal_packet *packet)
{
int data_length;
data_length = PAM_BP_LENGTH(prompt);
packet->at = 0;
append_data(packet, data_length, NULL);
PAM_BP_EXTRACT(prompt, 0, data_length, packet->buffer);
fprintf(stderr, "server received[%d]: {%d|0x%.2x|%s}\n",
data_length,
PAM_BP_SIZE(prompt), PAM_BP_RCONTROL(prompt),
PAM_BP_RDATA(prompt));
}
/*! Creates a duplicate of the \a buffer. The new buffer does not share internal
storage; they are completely independent from each other.
*/
static net_buffer *
duplicate_buffer(net_buffer *_buffer)
{
net_buffer_private *buffer = (net_buffer_private *)_buffer;
net_buffer* duplicate = create_buffer(0);
if (duplicate == NULL)
return NULL;
if (append_data(duplicate, buffer->data, buffer->size) != B_OK) {
free_buffer(duplicate);
return NULL;
}
copy_metadata(duplicate, buffer);
return duplicate;
}
char *create_digest(int length, const char *raw)
{
struct internal_packet temp_packet;
FILE *pipe;
temp_packet.length = temp_packet.at = 0;
temp_packet.buffer = NULL;
append_string(&temp_packet, "echo -n '", 0);
append_string(&temp_packet, raw, 0);
append_string(&temp_packet, "'|/usr/bin/md5sum -", 1);
fprintf(stderr, "am attempting to run [%s]\n", temp_packet.buffer);
pipe = popen(temp_packet.buffer, "r");
if (pipe == NULL) {
fprintf(stderr, "server: failed to run\n [%s]\n", temp_packet.buffer);
exit(1);
}
temp_packet.at = 0;
append_data(&temp_packet, 32, NULL);
if (fgets(temp_packet.buffer, 33, pipe) == NULL) {
fprintf(stderr, "server: failed to read digest\n");
exit(1);
}
if (strlen(temp_packet.buffer) != 32) {
fprintf(stderr, "server: digest was not 32 chars?? [%s]\n",
temp_packet.buffer);
exit(1);
}
fclose(pipe);
return temp_packet.buffer;
}
static void
filter_avcc(bgav_bsf_t* bsf, bgav_packet_t * in, bgav_packet_t * out)
{
uint8_t * ptr, *end;
int len = 0;
int nals_sent = 0;
avcc_t * priv = bsf->priv;
ptr = in->data;
end = in->data + in->data_size;
out->data_size = 0;
while(ptr < end - priv->nal_size_length)
{
switch(priv->nal_size_length)
{
case 1:
len = *ptr;
ptr++;
break;
case 2:
len = BGAV_PTR_2_16BE(ptr);
ptr += 2;
break;
case 4:
len = BGAV_PTR_2_32BE(ptr);
ptr += 4;
break;
default:
break;
}
append_data(out, ptr, len, nals_sent ? 3 : 4);
nals_sent++;
ptr += len;
}
}
/* @builtin-bind { '"', builtin_string }, */
int builtin_string(interpreter* interp) {
string accum, s;
int result;
unsigned begin;
accum = empty_string();
++interp->ip;
while (1) {
/* Scan for the next important character. */
for (begin = interp->ip; is_ip_valid(interp); ++interp->ip)
if (curr(interp) == '"' ||
curr(interp) == '$' ||
curr(interp) == '`' ||
curr(interp) == '\\' ||
curr(interp) == '%')
break;
/* Found important character or EOI. */
if (!is_ip_valid(interp)) {
print_error("Encountered end-of-input in string literal");
goto error;
}
/* Append everything in-between */
accum = append_data(accum,
string_data(interp->code) + begin,
string_data(interp->code) + interp->ip);
switch (curr(interp)) {
case '"': goto done;
case '$':
++interp->ip;
if (!is_ip_valid(interp)) {
print_error("Encountered end-of-input in string literal");
goto error;
}
/* Append value of this register */
accum = append_string(accum,
interp->registers[curr(interp)]);
touch_reg(interp, curr(interp));
break;
case '%':
s = stack_pop(interp);
if (!s) {
print_error("Stack underflow");
goto error;
}
accum = append_string(accum, s);
free(s);
break;
case '`':
if (!interp->initial_whitespace) {
print_error("Initial whitespace (`) not available in this context.");
goto error;
}
accum = append_string(accum, interp->initial_whitespace);
break;
case '\\':
result = builtin_escape(interp);
if (!result) goto error;
if (result == 2) break; /* Didn't push anything */
s = stack_pop(interp);
/* Popping will always succeed if escape returned success. */
accum = append_string(accum, s);
free(s);
break;
}
/* All the above (which don't goto elsewhere) leave the IP on the end of
* whatever special thing they did.
*/
++interp->ip;
}
done:
stack_push(interp, accum);
return 1;
error:
diagnostic(interp, NULL);
free(accum);
return 0;
}
void append_string(struct internal_packet *packet, const char *string,
int with_nul)
{
append_data(packet, strlen(string) + (with_nul ? 1:0), string);
}
/*+*******************************************************
* Decode simulation data
*
* driv_new_sim_self_p self
* This simulator instance. Normally only one
* ever exists.
*
* uint8 data_stream
* The raw stream of bytes. See "ISos Simulation
* Protocol v 1.01" for more information.
*
* int data_size
* Number of bytes in data_stream
*
* int blocking
* Zero to return when unable to process more data
* or non-zero to block until all data is processed.
*
* This function operates in two modes: blocking and
* non-blocking. Non-blocking operation is strongly
* recommended for serial connections while blocking
* operation normally is used when reading from rom/ram.
*
* Details: a buffer is held in self->decoder.buf whenever
* the state is not one of the idle ones (idle or
* idle_got_escape).
********************************************************+*/
void
Simulation::decode_data(const uint8 * data_stream,
int32 data_size,
int reconnect,
int /*blocking*/)
{
int32 i;
uint8 data;
isabTime now;
/* Remember a reconnect until a packet is dispatched succesfully */
decoder.reconnected = decoder.reconnected || reconnect;
if (reconnect) {
if (decoder.state == decoder_in_packet ||
decoder.state == decoder_in_packet_got_escape) {
delete(decoder.cmdBeingAssembled);
decoder.cmdBeingAssembled = NULL;
}
decoder.state = decoder_idle;
}
for (i = 0; i < data_size; i++) {
data = data_stream[i];
switch (decoder.state) {
case decoder_idle:
/* Hunt for escape to start a new frame */
if (data == ESCAPE_CHAR) {
decoder.state = decoder_idle_got_escape;
}
break;
case decoder_idle_got_escape:
/* Check for proper frame start */
if (data >= 0x01 && data <= 0x7e) {
if (decoder.cmdBeingAssembled) {
delete decoder.cmdBeingAssembled;
}
decoder.cmdBeingAssembled = new struct SimCommand;
decoder.cmdBeingAssembled->rxTime = now;
decoder.cmdBeingAssembled->pktType = data;
decoder.cmdBeingAssembled->numBytes = 0;
decoder.state = decoder_in_packet;
break;
}
decoder.state = decoder_idle;
break;
case decoder_in_packet:
if (data == ESCAPE_CHAR) {
decoder.state = decoder_in_packet_got_escape;
break;
}
append_data(data);
break;
case decoder_in_packet_got_escape:
if (data == TERMINATE_CHAR) {
DBG("got complete packet of type %i, length %i\n",
decoder.cmdBeingAssembled->pktType,
decoder.cmdBeingAssembled->numBytes);
if (decoder.cmdBeingAssembled->numBytes < (4+1) ) {
ERR("which was too short (only %i < 5 bytes)\n",
decoder.cmdBeingAssembled->numBytes);
}
decoder.cmdBeingAssembled->reconnect = (decoder.reconnected != 0);
decoder.reconnected = 0;
dispatcher.cmdQueue.push(decoder.cmdBeingAssembled);
decoder.cmdBeingAssembled = NULL;
if (dispatcher.next_command == NULL) {
/* Was empty before, need to kickstart it */
setupForNextCommand();
}
decoder.state = decoder_idle;
break;
}
if (data == ESCAPE_REPLACEMENT_CHAR) {
/* State may be overridden by append_data */
decoder.state = decoder_in_packet;
append_data(ESCAPE_CHAR);
break;
}
/* Any other data is a new packet. Ignore it, and
* synchronize to the next packet. */
delete(decoder.cmdBeingAssembled);
decoder.cmdBeingAssembled = NULL;
decoder.state = decoder_idle;
break;
}
}
}
//------------------------------------------------------------------------------
void
append_data( const std::string& str_data )
{
return append_data( str_data.c_str(), (Elf_Word)str_data.size() );
}
void append_cmd(const char* a, parsed_data_t* parsed)
{
append_data(a, &parsed->numCmds, &parsed->cmdCnt, &parsed->commands);
}
void append_dep(const char* a, parsed_data_t* parsed)
{
append_data(a, &parsed->numDeps, &parsed->depsCnt, &parsed->deps);
}
/* Constructs and queues a request packet describing the http query pointed
* to by 'start'.
*/
int make_request_packet(Server *serv, int fd, int num_chars)
{
struct sockaddr_in client_name, local_name;
int client_namelen, local_namelen;
int free_start, free_end;
int packet_length;
char *request;
int len;
client_namelen = sizeof(struct sockaddr_in);
if (getpeername(fd, (struct sockaddr *) &client_name, &client_namelen) < 0)
{
syslog(LOG_INFO, "make_request_packet: failed to get peer "
"name: %m\n");
return 0;
}
local_namelen = sizeof(struct sockaddr_in);
if (getsockname(fd, (struct sockaddr *) &local_name, &local_namelen) < 0)
{
syslog(LOG_INFO, "make_request_packet: failed to get sock name: %m\n");
return 0;
}
change_state(serv, fd, fs_requested_backend);
/* locate the free end of the buffer (possibly appending to previous
* control packets) */
append_data(serv, serv->control_fd, &free_start, &free_end, fs_output);
/* reserve the first 4 bytes of the packet for the size field */
packet_length = PAK_COM_OFF;
/* add command field to packet */
serv->writebuf.buffer[free_start + packet_length++] = PAK_REQUEST;
/* add unique ID field to packet */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
(getpid() & 0xffff) | (fd << 16), 1);
/* add client IP field to packet */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
client_name.sin_addr.s_addr, 0);
/* add local IP field to packet */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
local_name.sin_addr.s_addr, 0);
/* add local port field to packet */
write_short(&serv->writebuf.buffer[free_start], &packet_length,
serv->port, 1);
/* write the http headers */
request = &serv->writebuf.buffer[serv->writebuf.pos[fd]];
while (request[0] == '\r' || request[0] == '\n')
request++;
for (len = 0; len < num_chars && !isspace(request[len]); len++)
;
if (len < num_chars)
{
write_string(&serv->writebuf.buffer[free_start], &packet_length,
"method");
write_string_n(&serv->writebuf.buffer[free_start], &packet_length,
request, len);
num_chars -= len;
request += len;
for (len = 0; len < num_chars && isspace(request[len]); len++)
;
if (len < num_chars)
{
num_chars -= len;
request += len;
for (len = 0; request[len] && !isspace(request[len]); len++)
;
write_string(&serv->writebuf.buffer[free_start], &packet_length,
"uri");
write_string_n(&serv->writebuf.buffer[free_start], &packet_length,
request, len);
num_chars -= len;
request += len;
for (len = 0; len < num_chars && isspace(request[len]); len++)
;
if (len < num_chars)
{
num_chars -= len;
request += len;
for (len = 0; request[len] && !isspace(request[len]); len++)
;
write_string(&serv->writebuf.buffer[free_start],
&packet_length, "version");
write_string_n(&serv->writebuf.buffer[free_start],
&packet_length, request, len);
/* each line should end with \r\n. Be a bit lenient, and
* allow just \r or \n, too. End of request is indicated
* by two such lines in a row */
if (request[len] == '\r')
len++;
if (request[len] == '\n')
len++;
num_chars -= len;
request += len;
/* find "field: value\r\n" on successive lines, adding them
* to the buffer as field\0value\0 */
while (num_chars > 0 && request[0] != '\r' &&
request[0] != '\n')
{
for (len = 0; len < num_chars && request[len] != ':' &&
request[len] != '\r' && request[len] != '\n'; len++)
;
if (len < num_chars && request[len] == ':')
{
write_string_n(&serv->writebuf.buffer[free_start],
&packet_length, request, len);
for (len++; len < num_chars && isspace(request[len]);
len++)
;
num_chars -= len;
request += len;
for (len = 0; len < num_chars && request[len] != '\r' &&
request[len] != '\n'; len++)
;
write_string_n(&serv->writebuf.buffer[free_start],
&packet_length, request, len);
}
if (request[len] == '\r')
len++;
if (request[len] == '\n')
len++;
num_chars -= len;
request += len;
}
}
}
}
/* set first 4 bytes of packet to the total packet length */
write_long(&serv->writebuf.buffer[free_start], NULL,
packet_length, 1);
/* add the packet to the output buffer properly */
if (free_end - free_start < packet_length)
fatal(serv, "request packet overflowed the buffer\n");
add_data(serv, serv->control_fd, NULL, free_start, packet_length,
fs_output);
return 1;
}
int make_backend_error_packet(Server *serv, int fd, u32 ip, u16 nbo_port)
{
struct sockaddr_in local_name;
struct sockaddr_in remote_name;
int local_namelen;
int remote_namelen;
int packet_length;
int free_start, free_end;
local_namelen = sizeof(struct sockaddr_in);
if (getsockname(fd, (struct sockaddr *) &local_name, &local_namelen) < 0)
{
syslog(LOG_INFO, "make_backend_error_packet: failed to get sock "
"name: %m\n");
return 0;
}
/* locate the free end of the buffer (possibly appending to previous
* control packets) */
append_data(serv, serv->control_fd, &free_start, &free_end, fs_output);
packet_length = PAK_COM_OFF;
/* write control code */
serv->writebuf.buffer[free_start + packet_length++] = PAK_BE_ERROR;
/* write unique id */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
(getpid() & 0xffff) | (fd << 16), 1);
/* add local IP field to packet */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
local_name.sin_addr.s_addr, 0);
/* add local port field to packet */
write_short(&serv->writebuf.buffer[free_start], &packet_length,
serv->port, 1);
if (serv->fd_partner[fd] == -1)
{
/* the connection failed straight away, so we've still got the ip
* and port (already in network byte order) to use */
write_long(&serv->writebuf.buffer[free_start], &packet_length, ip, 0);
write_short(&serv->writebuf.buffer[free_start], &packet_length,
nbo_port, 0);
}
else
{
/* else the partner (which is the failed backend fd) has the ip and
* port stored in serv->fd_connection_* */
write_long(&serv->writebuf.buffer[free_start], &packet_length,
serv->fd_connection_ip[serv->fd_partner[fd]], 0);
write_short(&serv->writebuf.buffer[free_start], &packet_length,
serv->fd_connection_port[serv->fd_partner[fd]], 1);
}
/* add client IP field to packet */
remote_namelen = sizeof(struct sockaddr_in);
if (getpeername(fd, (struct sockaddr *) &remote_name,
&remote_namelen) == -1)
{
syslog(LOG_INFO, "make_backend_error_packet: failed to getpeer "
"name: %m\n");
return 0;
}
write_long(&serv->writebuf.buffer[free_start], &packet_length,
remote_name.sin_addr.s_addr, 0);
/* write length */
write_long(&serv->writebuf.buffer[free_start], NULL, packet_length, 1);
/* add the packet to the output buffer properly */
if (free_end - free_start < packet_length)
fatal(serv, "unable to fit backend_error packet in static buffer\n");
add_data(serv, serv->control_fd, NULL, free_start, packet_length,
fs_output);
return 1;
}
