void EAPOL::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
#ifdef TINS_DEBUG
assert(total_sz >= header_size());
#endif
std::memcpy(buffer, &_header, sizeof(_header));
write_body(buffer + sizeof(_header), total_sz - sizeof(_header));
}
int
body_cb (http_parser *p, const char *buf, size_t len, char partial)
{
client_t *client = get_client(p);
if(max_content_length <= client->body_readed + len){
client->bad_request_code = 413;
return -1;
}
if(client->body_type == BODY_TYPE_NONE){
if(client->body_length == 0){
//Length Required
client->bad_request_code = 411;
return -1;
}
//default memory stream
#ifdef DEBUG
printf("client->body_length %d \n", client->body_length);
#endif
client->body_type = BODY_TYPE_BUFFER;
#ifdef DEBUG
printf("BODY_TYPE_BUFFER \n");
#endif
}
write_body(client, buf, len);
return 0;
}
void EAPOL::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
OutputMemoryStream stream(buffer, total_sz);
length(total_sz - 4);
stream.write(header_);
memcpy(buffer, &header_, sizeof(header_));
write_body(stream);
}
int write_body__(int * id, double * t, double * m,
double r[3], double v[3])
{
body_t b;
b.id = *id;
b.t = *t;
b.m = *m;
int k;
for(k=0;k<3;k++)b.r[k] = r[k];
for(k=0;k<3;k++)b.v[k] = v[k];
write_body(stdout, &b);
return 0;
}
static int
body_cb(http_parser *p, const char *buf, size_t len)
{
request *req = get_current_request(p);
DEBUG("body_cb");
if(max_content_length < req->body_readed + len){
DEBUG("set request code %d", 413);
req->bad_request_code = 413;
return -1;
}
if(req->body_type == BODY_TYPE_NONE){
if(req->body_length == 0 && !(p->flags & F_CHUNKED)){
//Length Required
DEBUG("set request code %d", 411);
req->bad_request_code = 411;
return -1;
}
if(req->body_length > client_body_buffer_size){
//large size request
FILE *tmp = tmpfile();
if(tmp < 0){
req->bad_request_code = 500;
return -1;
}
req->body = tmp;
req->body_type = BODY_TYPE_TMPFILE;
DEBUG("BODY_TYPE_TMPFILE");
}else{
//default memory stream
DEBUG("client->body_length %d", req->body_length);
req->body = new_buffer(req->body_length, 0);
req->body_type = BODY_TYPE_BUFFER;
DEBUG("BODY_TYPE_BUFFER");
}
}
write_body(req, buf, len);
return 0;
}
void write_message(rc_t status)
{
readfunc_t rf = NULL; /* assignment to quench warning */
void *rfarg = 0; /* assignment to quench warning */
textdata_t *text;
bool seen_subj = false;
build_spam_header();
if (!passthrough)
{
write_spam_info();
}
else
{
eol = NULL;
/* initialize */
rf = read_mem;
text = textblock_head();
rfarg = &text;
seen_subj = write_header(status, rf, rfarg);
if (!seen_subj) {
if (status == RC_SPAM && spam_subject_tag != NULL)
(void) fprintf(fpo, "Subject: %s%s", spam_subject_tag, eol);
if (status == RC_UNSURE && unsure_subject_tag != NULL)
(void) fprintf(fpo, "Subject: %s%s", unsure_subject_tag, eol);
}
write_body(rf, rfarg);
if (verbose || Rtable) {
if (fflush(fpo) || ferror(fpo))
cleanup_exit(EX_ERROR, 1);
}
}
return;
}
void process_requests(void)
{
int retval = 0;
request *current, *trailer;
current = request_ready;
while (current) {
#ifdef CRASHDEBUG
crashdebug_current = current;
#endif
if (current->buffer_end) {
req_flush(current);
if (current->status == CLOSE)
retval = 0;
else
retval = 1;
} else {
switch (current->status) {
case READ_HEADER:
case ONE_CR:
case ONE_LF:
case TWO_CR:
retval = read_header(current);
break;
case BODY_READ:
retval = read_body(current);
break;
case BODY_WRITE:
retval = write_body(current);
break;
case WRITE:
retval = process_get(current);
break;
case PIPE_READ:
retval = read_from_pipe(current);
break;
case PIPE_WRITE:
retval = write_from_pipe(current);
break;
default:
retval = 0;
#if 0
fprintf(stderr, "Unknown status (%d), closing!\n",
current->status);
#endif
break;
}
}
if (lame_duck_mode)
SQUASH_KA(current);
switch (retval) {
case -1: /* request blocked */
trailer = current;
current = current->next;
block_request(trailer);
break;
default: /* everything else means an error, jump ship */
send_r_error(current);
/* fall-through */
case 0: /* request complete */
trailer = current;
current = current->next;
free_request(&request_ready, trailer);
break;
case 1: /* more to do */
current->time_last = time_counter;
current = current->next;
break;
}
}
#ifdef CRASHDEBUG
crashdebug_current = current;
#endif
}
void process_requests(int server_sock)
{
int retval = 0;
request *current, *trailer;
if (pending_requests) {
get_request(server_sock);
#ifdef ORIGINAL_BEHAVIOR
pending_requests = 0;
#endif
}
current = request_ready;
while (current) {
time(¤t_time);
retval = 1; /* emulate "success" in case we don't have to flush */
if (current->buffer_end && /* there is data in the buffer */
current->status < TIMED_OUT) {
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval >= 0) {
/* notice the >= which is different from below?
Here, we may just be flushing headers.
We don't want to return 0 because we are not DONE
or DEAD */
retval = 1;
}
}
if (retval == 1) {
switch (current->status) {
case READ_HEADER:
case ONE_CR:
case ONE_LF:
case TWO_CR:
retval = read_header(current);
break;
case BODY_READ:
retval = read_body(current);
break;
case BODY_WRITE:
retval = write_body(current);
break;
case WRITE:
retval = process_get(current);
break;
case PIPE_READ:
retval = read_from_pipe(current);
break;
case PIPE_WRITE:
retval = write_from_pipe(current);
break;
case IOSHUFFLE:
#ifdef HAVE_SENDFILE
retval = io_shuffle_sendfile(current);
#else
retval = io_shuffle(current);
#endif
break;
case DONE:
/* a non-status that will terminate the request */
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval > 0) {
retval = 1;
}
break;
case TIMED_OUT:
case DEAD:
retval = 0;
current->buffer_end = 0;
SQUASH_KA(current);
break;
default:
retval = 0;
fprintf(stderr, "Unknown status (%d), "
"closing!\n", current->status);
current->status = DEAD;
break;
}
}
if (sigterm_flag)
{
SQUASH_KA(current);
}
/* we put this here instead of after the switch so that
* if we are on the last request, and get_request is successful,
* current->next is valid!
*/
if (pending_requests)
get_request(server_sock);
switch (retval) {
case -1: /* request blocked */
trailer = current;
current = current->next;
block_request(trailer);
break;
case 0: /* request complete */
current->time_last = current_time;
trailer = current;
current = current->next;
free_request(trailer);
break;
case 1: /* more to do */
current->time_last = current_time;
current = current->next;
break;
default:
log_error_doc(current);
fprintf(stderr, "Unknown retval in process.c - "
"Status: %d, retval: %d\n", current->status, retval);
current->status = DEAD;
current = current->next;
break;
}
}
}
void linphone_gtk_push_text(GtkWidget *w, const LinphoneAddress *from,
gboolean me,LinphoneChatRoom *cr,LinphoneChatMessage *msg, gboolean hist){
GtkTextView *text=GTK_TEXT_VIEW(linphone_gtk_get_widget(w,"textview"));
GtkTextBuffer *buffer=gtk_text_view_get_buffer(text);
GtkTextIter iter;
char *from_str=linphone_address_as_string_uri_only(from);
gchar *from_message=(gchar *)g_object_get_data(G_OBJECT(w),"from_message");
GHashTable *table=(GHashTable*)g_object_get_data(G_OBJECT(w),"table");
const GRegex *uri_regex = get_uri_regex();
GMatchInfo *match_info = NULL;
const char *message = linphone_chat_message_get_text(msg);
time_t t;
char buf[80];
time_t tnow;
struct tm *tm;
int tnow_day;
int tnow_year;
int pos = 0, start, end;
gtk_text_buffer_get_end_iter(buffer, &iter);
if (g_strcmp0(from_message,from_str)!=0){
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, get_display_name(from), -1,
"from", me ? "me" : NULL, NULL);
gtk_text_buffer_insert_with_tags_by_name(buffer,&iter, " : ", -1,
"from", me ? "me" : NULL, NULL);
gtk_text_buffer_insert(buffer,&iter,"\n",-1);
g_free(from_message);
g_object_set_data(G_OBJECT(w),"from_message",g_strdup(from_str));
}
ms_free(from_str);
// Inserts message body and tags URIs as hypertext links
if(message) {
g_regex_match(uri_regex, message, 0, &match_info);
while(g_match_info_matches(match_info)) {
g_match_info_fetch_pos(match_info, 0, &start, &end);
if(pos < start) write_body(buffer, &iter, &message[pos], start-pos, me, FALSE);
write_body(buffer, &iter, &message[start], end-start, me, TRUE);
pos = end;
g_match_info_next(match_info, NULL);
}
if(pos < strlen(message)) write_body(buffer, &iter, &message[pos], -1, me, FALSE);
gtk_text_buffer_insert(buffer,&iter,"\n",-1);
g_match_info_free(match_info);
}
t=linphone_chat_message_get_time(msg);
switch (linphone_chat_message_get_state (msg)){
case LinphoneChatMessageStateInProgress:
g_hash_table_insert(table,(gpointer)msg,GINT_TO_POINTER(gtk_text_iter_get_line(&iter)));
gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Sending ..",-1,
"status", me ? "me" : NULL, NULL);
//g_object_set_data(G_OBJECT(w),"table",table);
break;
case LinphoneChatMessageStateDelivered:
tnow=time(NULL);
tm=localtime(&tnow);
tnow_day=tm->tm_yday;
tnow_year=tm->tm_year;
tm=localtime(&t);
if(tnow_day != tm->tm_yday || (tnow_day == tm->tm_yday && tnow_year != tm->tm_year)) {
strftime(buf,80,"%a %x, %H:%M",tm);
} else {
strftime(buf,80,"%H:%M",tm);
}
gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,buf,-1,
"status", me ? "me" : NULL, NULL);
break;
case LinphoneChatMessageStateNotDelivered:
gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Message not sent",-1,
"status", me ? "me" : NULL, NULL);
break;
default : gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Sending ..",-1,
"status", me ? "me" : NULL, NULL);
}
gtk_text_buffer_insert(buffer,&iter,"\n",-1);
g_idle_add((GSourceFunc)scroll_to_end,text);
}
void process_requests(int server_s, struct soap *soap)/*by SeanHou*/
{
/* :TODO:Monday, December 01, 2014 11:17:36 HKT:SeanHou: */
int OnvifEN = 0;
int lookupindex = 0;
char service_uri[100] = "";
memset((void*)&soap->peer, 0, sizeof(soap->peer));
soap->socket = SOAP_INVALID_SOCKET;
soap->error = SOAP_OK;
soap->errmode = 0;
soap->keep_alive = 0;
fprintf(stderr, "Warning:" \
"(==>%s).\n", __func__);
/* :TODO:End--- */
int retval = 0;
request *current, *trailer;
if (pending_requests) {
get_request(server_s);
#ifdef ORIGINAL_BEHAVIOR
pending_requests = 0;
#endif
}
current = request_ready;
while (current) {
/* :TODO:Monday, December 01, 2014 11:18:42 HKT:SeanHou: juge is onvif */
OnvifEN = isonvif(current->client_stream, service_uri, &lookupindex);
if(OnvifEN == 1)
{
fprintf(stderr, "[boa:onvif] Warning: is onvif line[%d]remote port[%d]h2ns[%d]remote ip[%s]\n", __LINE__, current->remote_port, htons(current->remote_port), current->remote_ip_addr);
struct sockaddr_in onvif_client_addr;
memset(&onvif_client_addr, 0, sizeof(onvif_client_addr));
onvif_client_addr.sin_family = AF_INET;
onvif_client_addr.sin_port = htons(current->remote_port);//随机端口
onvif_client_addr.sin_addr.s_addr = inet_addr(current->remote_ip_addr);//
soap->socket = current->fd;
soap->peer = onvif_client_addr;
if (soap_valid_socket(soap->socket))
{
soap->ip = ntohl(soap->peer.sin_addr.s_addr);
soap->port = (int)ntohs(soap->peer.sin_port);
soap->keep_alive = (((soap->imode | soap->omode) & SOAP_IO_KEEPALIVE) != 0);
}
g_onvif_buffer = (char *)soap_malloc(soap, sizeof(current->client_stream));
strcpy(g_onvif_buffer, current->client_stream);//mark
soap_begin_recv(soap);
if (soap_envelope_begin_in(soap))
{
soap_send_fault(soap);
}
if (soap_recv_header(soap))
{
soap_send_fault(soap);
}
if (soap_body_begin_in(soap))
{
soap_send_fault(soap);
}
int errorCode = 0;
if (errorCode = soap_serve_request(soap))
{
fprintf(stderr, "[boa:onvif]soap_serve_request fail, errorCode %d \n", errorCode);
soap_send_fault(soap);
}
memset(current->client_stream, 0, CLIENT_STREAM_SIZE );
soap_dealloc(soap, NULL);
soap_destroy(soap);
soap_end(soap);
current->status = DONE;
close(soap->socket);
continue;
}
/* :TODO:End--- */
time(¤t_time);
if (current->buffer_end && /* there is data in the buffer */
current->status != DEAD && current->status != DONE) {
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval >= 0) {
/* notice the >= which is different from below?
Here, we may just be flushing headers.
We don't want to return 0 because we are not DONE
or DEAD */
retval = 1;
}
} else {
switch (current->status) {
case READ_HEADER:
case ONE_CR:
case ONE_LF:
case TWO_CR:
retval = read_header(current);
break;
case BODY_READ:
retval = read_body(current);
break;
case BODY_WRITE:
retval = write_body(current);
break;
case WRITE:
retval = process_get(current);
break;
case PIPE_READ:
retval = read_from_pipe(current);
break;
case PIPE_WRITE:
retval = write_from_pipe(current);
break;
case DONE:
/* a non-status that will terminate the request */
retval = req_flush(current);
/*
* retval can be -2=error, -1=blocked, or bytes left
*/
if (retval == -2) { /* error */
current->status = DEAD;
retval = 0;
} else if (retval > 0) {
retval = 1;
}
break;
case DEAD:
retval = 0;
current->buffer_end = 0;
SQUASH_KA(current);
break;
default:
retval = 0;
fprintf(stderr, "Unknown status (%d), "
"closing!\n", current->status);
current->status = DEAD;
break;
}
}
if (sigterm_flag)
SQUASH_KA(current);
/* we put this here instead of after the switch so that
* if we are on the last request, and get_request is successful,
* current->next is valid!
*/
if (pending_requests)
get_request(server_s);
switch (retval) {
case -1: /* request blocked */
trailer = current;
current = current->next;
block_request(trailer);
break;
case 0: /* request complete */
current->time_last = current_time;
trailer = current;
current = current->next;
free_request(&request_ready, trailer);
break;
case 1: /* more to do */
current->time_last = current_time;
current = current->next;
break;
default:
log_error_time();
fprintf(stderr, "Unknown retval in process.c - "
"Status: %d, retval: %d\n", current->status, retval);
current = current->next;
break;
}
}
}