static int
answer_to_connection (void *cls, struct MHD_Connection *connection,
const char *url, const char *method,
const char *version, const char *upload_data,
size_t *upload_data_size, void **con_cls) {
if (!*con_cls) { // new request
if (strcmp(method, "POST") == 0) {
if(!checkIP(connection)) {
logger.debug("Rejected packet from " + getIP(connection));
return MHD_NO;
}
// create the persistent connection info object
struct connection_info *con_info = new struct connection_info;
con_info->message = nullptr;
con_info->message_len = 0;
con_info->valid = true;
*con_cls = (void*)con_info;
return MHD_YES;
}
logger.debug("Rejected non-POST message");
return MHD_NO;
}
if (strcmp(method, "POST") == 0) {
struct connection_info *con_info = (struct connection_info*)*con_cls;
// if there is some data
if (*upload_data_size != 0) {
// process all of the data with the postprocessor
char *newmsg = new char[con_info->message_len + *upload_data_size + 1];
if (con_info->message) {
strncpy(newmsg, con_info->message, con_info->message_len);
delete[] con_info->message;
}
strncpy(newmsg + con_info->message_len, upload_data, *upload_data_size);
con_info->message_len += *upload_data_size;
newmsg[con_info->message_len] = '\0';
con_info->message = newmsg;
*upload_data_size = 0;
return MHD_YES;
} else {
return send_page(connection, " ");
}
}
return MHD_NO;
}
/* send notifcations out to all people(s)
state is the 1 (up) or 0 (down), -1 error
*/
void send_notifications(char *hostname, int port, int state) {
char buffer[255];
MYSQL *mysqlConnection;
MYSQL_RES *res;
MYSQL_ROW row;
char qry[1024], buf[128];
int ql;
mysqlConnection = init_sql();
if (!mysqlConnection) return;
sprintf(buf, "%s %d %s", hostname, port, ((state == 1) ? "up" : "down") );
strcpy(qry, "SELECT pager,send_page,email,send_email,id FROM notifications");
ql = strlen(qry);
if (mysql_real_query(mysqlConnection, qry, ql)) return;
if (! (res = mysql_store_result(mysqlConnection)) ) return;
while ((row = mysql_fetch_row(res))) {
if (wants_notification(hostname, atoi(row[4]))) {
#ifdef ARCH_HTTP_PAGE
if (strcmp(row[1], "1") == 0) { /* send page */
/* check if they want to receive pages for this server */
sprintf(buffer, " sending page to %s...\n", row[0]);
_log(buffer, 1);
send_page(row[0], buf);
}
#endif
if (strcmp(row[3], "1") == 0) { /* send e-mail */
sprintf(buffer, " sending email to %s...\n", row[2]);
_log(buffer, 1);
send_email(row[2], buf);
}
}
}
mysql_free_result(res);
close_sql(mysqlConnection);
}
void handle_http_req(int sfd, char *line){
int len;
if(!strncmp(line, "GET /", 5)){
parse_dst_url(line+5);
len = strlen(dst_url);
if((dst_url[len-4] == '.') &&
(dst_url[len-3] == 'i') &&
(dst_url[len-2] == 'c') &&
(dst_url[len-1] == 'o')){
close_socket(sfd, T_HTTP);
return;
}
send_page(sfd, NULL, dst_url);
}
else
close_socket(sfd, T_HTTP);
}
static void
tx_callback(void *arg)
{
struct deluge_object *obj;
obj = (struct deluge_object *)arg;
if(obj->current_tx_page >= 0 && obj->tx_set) {
send_page(obj, obj->current_tx_page);
/* Deluge T.2. */
if(obj->tx_set) {
packetbuf_set_attr(PACKETBUF_ATTR_PACKET_TYPE,
PACKETBUF_ATTR_PACKET_TYPE_STREAM);
ctimer_reset(&tx_timer);
} else {
packetbuf_set_attr(PACKETBUF_ATTR_PACKET_TYPE,
PACKETBUF_ATTR_PACKET_TYPE_STREAM_END);
obj->current_tx_page = -1;
transition(DELUGE_STATE_MAINTAIN);
}
}
}
// For now GET is not a request supported for now
int Server::answer_get(MHD_Connection* connection, const char *url){
printf("IS IT A GET REQUEST\n");
if(strcmp(url, "/GetAvailableFactories") == 0){
printf("GetAvailableFactories %ld\n", fAvailableFactories.size());
string answerstring("");
for(map<string, pair<string, llvm_dsp_factory*> >::iterator it = fAvailableFactories.begin(); it != fAvailableFactories.end(); it++){
answerstring += " " + it->first;
answerstring += " " + it->second.first;
}
return send_page(connection, answerstring.c_str(), answerstring.size(), MHD_HTTP_OK, "text/plain");
} else {
return MHD_NO;
}
}
static void send_entry(
Operation *op,
SlapReply *rs,
sort_op *so)
{
Debug(LDAP_DEBUG_TRACE,
"%s: response control: status=%d, text=%s\n",
debug_header, rs->sr_err, SAFESTR(rs->sr_text, "<None>"));
if ( !so->so_tree )
return;
/* RFC 2891: If critical then send the entries iff they were
* successfully sorted. If non-critical send all entries
* whether they were sorted or not.
*/
if ( (op->o_ctrlflag[sss_cid] != SLAP_CONTROL_CRITICAL) ||
(rs->sr_err == LDAP_SUCCESS) )
{
if ( so->so_vlv > SLAP_CONTROL_IGNORED ) {
send_list( op, rs, so );
} else {
/* Get the first node to send */
TAvlnode *start_node = tavl_end(so->so_tree, TAVL_DIR_LEFT);
so->so_tree = start_node;
if ( so->so_paged <= SLAP_CONTROL_IGNORED ) {
/* Not paged result search. Send all entries.
* Set the page size to the number of entries
* so that send_page() will send all entries.
*/
so->so_page_size = so->so_nentries;
}
send_page( op, rs, so );
}
}
}
void* worker_thread(void* myid){
stats_message work_stats;
request recived_request;
pthread_mutex_lock(&mutex);
recived_request=pipe_read(0);
/* Search file with html page and send to client*/
send_page(recived_request.socket_id);
work_stats.mtype=1;
strcpy(work_stats.request_type,recived_request.request_type);
strcpy(work_stats.file,recived_request.request_file);
work_stats.thread_number=(int)myid;
work_stats.entry_time[0]=1;
work_stats.entry_time[1]=2;
work_stats.end_time[0]=3;
work_stats.end_time[1]=4;
if(msgsnd(queue, &work_stats, sizeof(stats_message)-sizeof(long), 0)==-1){/*está a dar erro aqui*/
perror("Message Queue Sending");
}
printf("[Worker]Data to write on file\n");
printf("--------------------------------\n");
printf("\tMyType:%lu\n",work_stats.mtype);
printf("\tRequest Type:%s\n",work_stats.request_type);
printf("\tFile:%s\n",work_stats.file);
printf("\tThread Number:%d\n",work_stats.thread_number);
printf("\tEntry Time:%d:%d\n",work_stats.entry_time[0],work_stats.entry_time[1]);
printf("\tEnd Time:%d:%d\n",work_stats.end_time[0],work_stats.end_time[1]);
printf("-------------------------------\n");
pthread_mutex_unlock(&mutex);
/*depois de efectuar os pedidos vai para meter na message queue*/
}
int HTTPServer::answer_to_connection (void *cls, struct MHD_Connection *connection,
const char *url, const char *method,
const char *version, const char *upload_data,
size_t *upload_data_size, void **con_cls)
{
Logging::getInstance()->Log(Logging::INFO, "answering a connection: %s , %s, %s", url, method, upload_data);
if (NULL == *con_cls)
{
struct connection_info_struct *con_info;
con_info = (struct connection_info_struct *) malloc (sizeof (struct connection_info_struct));
if (NULL == con_info)
return MHD_NO;
con_info->answerstring = NULL;
if (0 == strcmp (method, "POST"))
{
con_info->postprocessor =
MHD_create_post_processor (connection, POSTBUFFERSIZE,
iterate_post, (void *) con_info);
if (NULL == con_info->postprocessor)
{
free (con_info);
return MHD_NO;
}
con_info->connectiontype = POST;
}
else
con_info->connectiontype = GET;
*con_cls = (void *) con_info;
return MHD_YES;
}
if (0 == strcmp (method, "GET"))
{
return send_page (connection, askpage);
}
if (0 == strcmp (method, "POST"))
{
struct connection_info_struct *con_info = (struct connection_info_struct *) *con_cls;
if (*upload_data_size != 0)
{
Logging::getInstance()->Log(Logging::INFO, "Just received a data stream with content:\n%s\n", upload_data);
std::string rxed_string(upload_data);
JsonObject rxed_json;
if(JsonObject::ParseFromString(rxed_string, rxed_json)){
unsigned long curr_time = current_date_time_msec();
long delay_time = -1;
if(rxed_json.hasValue("tx_time")){
unsigned long tx_time = rxed_json.GetUInt("tx_time");
delay_time = (long) curr_time - (long) tx_time;
}
rxed_json.PutUInt("rx_time",current_date_time_msec());
rxed_json.PutInt("delay_time",delay_time);
Logging::getInstance()->Log(Logging::INFO, "Just received a json message with content:\n%s\n", rxed_json.ToString().c_str());
//Add to Message Queue
GetMessageQueue()->pushToEnd(rxed_json);
}else{
//Data Stream is not JSON formatted
}
MHD_post_process (con_info->postprocessor, upload_data,
*upload_data_size);
*upload_data_size = 0;
return MHD_YES;
}
else if (NULL != con_info->answerstring)
return send_page (connection, con_info->answerstring);
}
return send_page (connection, errorpage);
}
static int answer_to_connection(void *cls, struct MHD_Connection *connection,
const INT1 *url, const char *method, const INT1 *version,
const INT1 *upload_data, size_t *upload_data_size, void **con_cls)
{
INT4 ret = 0;
UINT4 idx = 0;
if (NULL == *con_cls)
{
struct connection_info *conn_info = (struct connection_info *)gn_malloc(sizeof(struct connection_info));
if(NULL == conn_info)
{
return MHD_NO;
}
conn_info->connection_time = g_cur_sys_time.tv_sec;
*con_cls = (void *)conn_info;
return MHD_YES;
}
if (0 == strcmp(method, "GET"))
{
LOG_PROC("INFO", "Restful[%s]: [%s]", method, url);
g_rest_reply = proc_rest_msg(method, url, upload_data);
//todo ÅпÕ
ret = send_page(connection, g_rest_reply, MHD_HTTP_OK); //»Ø¸´ÏûÏ¢
memset((char *) upload_data, 0x0, *upload_data_size); //Çå¿Õ»º³åÇø
*upload_data_size = 0;
upload_data = NULL;
free(g_rest_reply);
return ret;
}
if (0 == strcmp(method, "POST") || 0 == strcmp(method, "DELETE")
|| 0 == strcmp(method, "PUT") || 0 == strcmp(method, "PATCH")
|| 0 == strcmp(method, "HEAD"))
{
struct connection_info *conn_info = *con_cls;
conn_info->connection_type = HTTP_POST;
if (*upload_data_size)
{
if(is_json(upload_data, *upload_data_size))
{
INT1 *tmp = (char*) upload_data;
for (idx = *upload_data_size; idx > 0; --idx)
{
if ('}' == tmp[idx])
{
tmp[idx + 1] = '\0';
break;
}
}
LOG_PROC("INFO", "Restful[%s]: [%s] %s\n", method, url, upload_data);
g_rest_reply = proc_rest_msg(method, url, upload_data);
memset((char *) upload_data, 0x0, *upload_data_size); //Çå¿Õ»º³åÇø
*upload_data_size = 0;
}
else
{
if(conn_info->connection_time - g_cur_sys_time.tv_sec > HTTP_TIMEOUT)
{
memset((char *) upload_data, 0x0, *upload_data_size); //Çå¿Õ»º³åÇø
*upload_data_size = 0;
return MHD_NO;
}
}
return MHD_YES;
}
else
{
ret = send_page(connection, g_rest_reply, MHD_HTTP_OK);
memset((char *) upload_data, 0x0, *upload_data_size); //Çå¿Õ»º³åÇø
*upload_data_size = 0;
upload_data = NULL;
gn_free((void **)&g_rest_reply);
return ret;
}
}
return ret;
}
/**
* A client has requested the given url using the given method
* (#MHD_HTTP_METHOD_GET, #MHD_HTTP_METHOD_PUT,
* #MHD_HTTP_METHOD_DELETE, #MHD_HTTP_METHOD_POST, etc). The callback
* must call MHD callbacks to provide content to give back to the
* client and return an HTTP status code (i.e. #MHD_HTTP_OK,
* #MHD_HTTP_NOT_FOUND, etc.).
*
* @param cls argument given together with the function
* pointer when the handler was registered with MHD
* @param url the requested url
* @param method the HTTP method used (#MHD_HTTP_METHOD_GET,
* #MHD_HTTP_METHOD_PUT, etc.)
* @param version the HTTP version string (i.e.
* #MHD_HTTP_VERSION_1_1)
* @param upload_data the data being uploaded (excluding HEADERS,
* for a POST that fits into memory and that is encoded
* with a supported encoding, the POST data will NOT be
* given in upload_data and is instead available as
* part of #MHD_get_connection_values; very large POST
* data *will* be made available incrementally in
* @a upload_data)
* @param upload_data_size set initially to the size of the
* @a upload_data provided; the method must update this
* value to the number of bytes NOT processed;
* @param con_cls pointer that the callback can set to some
* address and that will be preserved by MHD for future
* calls for this request; since the access handler may
* be called many times (i.e., for a PUT/POST operation
* with plenty of upload data) this allows the application
* to easily associate some request-specific state.
* If necessary, this state can be cleaned up in the
* global #MHD_RequestCompletedCallback (which
* can be set with the #MHD_OPTION_NOTIFY_COMPLETED).
* Initially, `*con_cls` will be NULL.
* @return #MHD_YES if the connection was handled successfully,
* #MHD_NO if the socket must be closed due to a serios
* error while handling the request
*/
static int
answer_to_connection(void *cls, struct MHD_Connection *connection,
const char *url, const char *method, const char *version, const char *upload_data, size_t * upload_data_size, void **con_cls)
{
if (*con_cls == NULL) {
printf("CON_CLS is NULL. Request-type: %s\n", method);
struct connection_info_struct *con_info;
con_info = malloc(sizeof(struct connection_info_struct));
if (con_info == NULL) {
return MHD_NO;
}
con_info->answerstring = NULL;
if (strcmp(method, "POST") == 0) {
con_info->postprocessor = MHD_create_post_processor(connection, POSTBUFFERSIZE, iterate_post, (void *) con_info);
if (con_info->postprocessor == NULL) {
free(con_info);
return MHD_NO;
}
con_info->connectiontype = POST;
} else if (strcmp(method, "DELETE") == 0) {
con_info->connectiontype = DELETE;
} else {
con_info->connectiontype = GET;
}
*con_cls = (void *) con_info;
return MHD_YES;
}
printf("CON_CLS is NOT NULL.\n");
if (0 == strcmp(method, "GET")) {
char modifiableUrl [strlen(url) + 1];
strncpy(modifiableUrl, url, sizeof modifiableUrl);
modifiableUrl[strlen(url)] = '\0';
char * argument = strtok(modifiableUrl, "/"); // remove api name
argument = strtok(NULL, "/");
int parsedArgument = atoi(argument);
int responseValue = hashGet(parsedArgument);
if (responseValue >= 0) {
char buffer[100]; // totally arbitrary but pretty big
sprintf(buffer, "200 - OK\nValue: %d\n", responseValue);
return send_page(connection, MHD_HTTP_OK, buffer);
} else if (responseValue == NOT_FOUND) {
return send_page(connection, 404, "404 - Not found\nThere are no entries matching your key.\n");
} else {
return send_page(connection, 500, "500 - Internal server error\n");
}
}
if (0 == strcmp(method, "DELETE")) {
printf("DELETE REQUEST to %s >>>\n", url);
char modifiableUrl [strlen(url) + 1];
strncpy(modifiableUrl, url, sizeof modifiableUrl);
modifiableUrl[strlen(url)] = '\0';
char * argument = strtok(modifiableUrl, "/"); // remove api name
argument = strtok(NULL, "/");
int parsedArgument = atoi(argument);
printf("Parsed as %d from %s\n", parsedArgument, argument);
int responseValue = hashDel(parsedArgument);
printf("Result: %d\n", responseValue);
if (responseValue >= 0) {
return send_page(connection, 200, "200 - OK\n");
} else if (responseValue == NOT_FOUND) {
return send_page(connection, 404, "404 - Not found\nThere are no entries matching your key.\n");
} else {
return send_page(connection, 500, "500 - Internal server error\n");
}
}
if (0 == strcmp(method, "POST")) {
struct connection_info_struct *con_info = *con_cls;
if (*upload_data_size != 0) {
MHD_post_process(con_info->postprocessor, upload_data, *upload_data_size);
*upload_data_size = 0;
return MHD_YES;
} else if (keySet && valueSet) {
keySet = 0;
valueSet = 0;
printf("Set %d:%d!\n", key, value);
if (hashSet(key, value)) {
const char *responseText = "201 - Created\n";
struct MHD_Response *response = MHD_create_response_from_buffer(strlen(responseText), (void*) responseText, MHD_RESPMEM_PERSISTENT);
char buffer[100]; // totally arbitrary but pretty big
sprintf(buffer, "http://localhost:%d%s/%d", port, url, key);
MHD_add_response_header (response, "Location", buffer);
int ret = MHD_queue_response (connection, 201, response);
MHD_destroy_response(response);
return MHD_YES;
} else {
return send_page(connection, 500, "500 - Internal server error\n");
}
} else {
return send_page(connection, MHD_HTTP_BAD_REQUEST, "400 - Malformed request\n");
}
}
return send_page(connection, MHD_HTTP_NOT_FOUND, "404 - Not found\n");
}
/***************************************************************************
* Function Name: cfe_web_bg_process
* Description : This function processes an HTTP request on a socket.
* Returns : None.
***************************************************************************/
static void cfe_web_bg_process(PSOCKET_INFO si)
{
char post_subst[] = {UPLOAD_FATAL, '\0'};
char *post_substs[] = {post_subst};
int close_tcp = 0;
switch( si->state )
{
case HTTP_READ_FIRST_HDR:
if( read_first_hdr( si->s, si->web_first_buf,
sizeof(si->web_first_buf), &si->web_buf_idx, &close_tcp ) == 0 )
{
/* Not all of the first header has been read yet. Try again later.*/
break;
}
/* The first header has been read. */
si->state = HTTP_READ_REMAINING_HDRS;
/* fall thru */
case HTTP_READ_REMAINING_HDRS:
if( read_remaining_hdrs( si->s, si->web_buf, sizeof(si->web_buf),
&si->web_buf_idx, &close_tcp, &si->post_content_length ) )
{
if( g_processing_cmd == 0 )
{
char *method = NULL;
char *path = NULL;
char *ptr = (char *) si->web_first_buf;
method = gettoken(&ptr);
if( method )
path = gettoken(&ptr);
/* Process the HTTP request. Only GET and POST are supported. */
if( method && path )
{
if( !strcmpi( method, "get" ) )
{
send_page( si->s, path, 1, NULL, 0 );
close_tcp = 1;
}
else
{
if( !strcmpi( method, "post" ) )
{
if( g_post_data_in_progress == 0 )
{
g_post_data_in_progress = 1;
si->state = HTTP_READ_POST_DATA;
}
else
{
send_error( si->s, 501, "Upload Busy",
(char*) 0,
"An image is already being uploaded." );
close_tcp = 1;
}
}
else
{
send_error( si->s, 501, "Not Implemented",
(char*) 0,
"That method is not implemented." );
close_tcp = 1;
}
}
}
else
{
send_error( si->s, 400, "Bad Request", (char *) 0,
"Can't parse request." );
close_tcp = 1;
}
}
else
{
/* A download and flash image command is being executed from
* the serial port console.
*/
send_error( si->s, 400, "Bad Request", (char *) 0,
"Console command is in progress." );
close_tcp = 1;
}
}
if( si->state != HTTP_READ_POST_DATA )
break;
case HTTP_READ_POST_DATA:
/* Read the post data, which contains an image to flash, into low
* memory.
*/
if( (post_subst[0] = read_post_data( si->s, POST_DATA_START,
si->post_content_length, &g_post_data_idx )) == UPLOAD_OK )
{
/* Verify that the post data is a valid image to flash. */
post_subst[0] = parse_post_data( si->s, POST_DATA_START,
g_post_data_idx, (unsigned char **) &g_image_start, &g_image_len,
&g_image_format );
}
switch( post_subst[0] )
{
case UPLOAD_PENDING:
break;
case UPLOAD_TCP_ERROR:
close_tcp = 1;
g_post_data_in_progress = 0;
g_post_data_idx = 0;
break;
case UPLOAD_OK:
/* Notify foreground to abort the console input so it can
* write the image to flash memory.
*/
g_console_abort = 1;
send_page(si->s, "/uploadinfo.html", 0, post_substs, 1);
close_tcp = 1;
g_post_data_idx = 0;
break;
default:
/* The image was downloaded OK but there was a problem with it
* so it could not be written to flash memory.
*/
send_page(si->s, "/uploadinfo.html", 0, post_substs, 1);
close_tcp = 1;
g_post_data_in_progress = 0;
g_post_data_idx = 0;
break;
}
break;
}
/* Close the socket if the HTTP transaction is done. */
if( close_tcp )
{
POLL();
tcp_close(si->s);
si->s = SOCKET_CLOSED;
si->state = HTTP_READ_FIRST_HDR;
si->web_buf_idx = 0;
si->post_content_length = 0;
}
} /* cfe_web_poll */
FUNCTION PRIVATE DEFINITION static int answer_to_connection
(
void *cls,
struct MHD_Connection * connection,
const char *url,
const char *method,
const char *version,
const char *upload_data,
size_t *upload_data_size,
void **con_cls
)
{
#ifdef DEBUG
std::printf("%s %s %s\n", version, method, url);
#endif
Str_t smethod(method);
if (*con_cls == NULL)
{
Connection_info_struct_t* con_info = new (VAR2STR(Connection_info_struct_t)) Connection_info_struct_t;
if (con_info == NULL) return MHD_NO;
con_info->answerstring.clear();
if (smethod.compare(txPOST) == 0)
{
con_info->postprocessor = MHD_create_post_processor(connection, POST_BUFFER_SIZE, iterate_post, (void *) con_info);
if (con_info->postprocessor == NULL)
{
#ifdef DEBUG
std::printf("[ERROR-LOG][deploy::answer_to_connection] POST Request not datas to process.\n");
#endif
delete con_info;
return MHD_NO;
}
con_info->connectiontype = POST;
}
else if (smethod.compare(txGET) == 0)
{
con_info->connectiontype = GET;
}
*con_cls = (void *) con_info;
return MHD_YES;
}
if (smethod.compare(txGET) == 0)
{
Str_t page, mimetype;
page_dispatcher(Str_t(url), page, mimetype);
return send_page (connection, page, mimetype);
}
if (smethod.compare(txPOST) == 0)
{
Connection_info_struct_t* con_info = reinterpret_cast<Connection_info_struct_t*>(*con_cls);
if (*upload_data_size != 0)
{
MHD_post_process (con_info->postprocessor, upload_data, *upload_data_size);
*upload_data_size = 0;
return MHD_YES;
}
else if (!con_info->post_key_value.empty())
{
}
}
Str_t page, mimetype;
deployapp::page_dispatcher("", page, mimetype);
return send_page (connection, page, mimetype);
}
static int sssvlv_op_search(
Operation *op,
SlapReply *rs)
{
slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
sssvlv_info *si = on->on_bi.bi_private;
int rc = SLAP_CB_CONTINUE;
int ok, need_unlock = 0;
sort_ctrl *sc;
PagedResultsState *ps;
vlv_ctrl *vc;
int sess_id;
if ( op->o_ctrlflag[sss_cid] <= SLAP_CONTROL_IGNORED ) {
if ( op->o_ctrlflag[vlv_cid] > SLAP_CONTROL_IGNORED ) {
sort_op so; memset(&so, 0, sizeof(so));
so.so_vlv_rc = LDAP_VLV_SSS_MISSING;
so.so_vlv = op->o_ctrlflag[vlv_cid];
LDAPControl *ctrls[2];
rc = pack_vlv_response_control( op, rs, &so, ctrls );
if ( rc == LDAP_SUCCESS ) {
ctrls[1] = NULL;
slap_add_ctrls( op, rs, ctrls );
}
rs->sr_err = LDAP_VLV_ERROR;
rs->sr_text = "Sort control is required with VLV";
goto leave;
}
/* Not server side sort so just continue */
return SLAP_CB_CONTINUE;
}
Debug(LDAP_DEBUG_TRACE,
"==> sssvlv_search: <%s> %s, control flag: %d\n",
op->o_req_dn.bv_val, op->ors_filterstr.bv_val,
op->o_ctrlflag[sss_cid]);
sc = op->o_controls[sss_cid];
if ( sc->sc_nkeys > si->svi_max_keys ) {
rs->sr_text = "Too many sort keys";
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
goto leave;
}
ps = ( op->o_pagedresults > SLAP_CONTROL_IGNORED ) ?
(PagedResultsState*)(op->o_pagedresults_state) : NULL;
vc = op->o_ctrlflag[vlv_cid] > SLAP_CONTROL_IGNORED ?
op->o_controls[vlv_cid] : NULL;
if ( ps && vc ) {
rs->sr_text = "VLV incompatible with PagedResults";
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
goto leave;
}
ldap_pvt_thread_mutex_lock( &sort_conns_mutex );
ok = need_unlock = 1;
sort_op *so = NULL;
/* Is there already a sort running on this conn? */
sess_id = find_session_by_context( si->svi_max_percon, op->o_conn->c_conn_idx, vc ? vc->vc_context : NO_VC_CONTEXT, ps ? ps->ps_cookie : NO_PS_COOKIE );
if ( sess_id >= 0 ) {
so = sort_conns[op->o_conn->c_conn_idx][sess_id];
if (so->so_running) {
/* another thread is handling, response busy to client */
ok = 0;
so = NULL;
} else {
/* Is it a continuation of a VLV search? */
if ( !vc || so->so_vlv <= SLAP_CONTROL_IGNORED ||
vc->vc_context != so->so_vcontext ) {
/* Is it a continuation of a paged search? */
if ( !ps || so->so_paged <= SLAP_CONTROL_IGNORED ||
op->o_conn->c_pagedresults_state.ps_cookie != ps->ps_cookie ) {
ok = 0;
} else if ( !ps->ps_size ) {
/* Abandoning current request */
ok = 0;
so->so_nentries = 0;
rs->sr_err = LDAP_SUCCESS;
}
}
if (( vc && so->so_paged > SLAP_CONTROL_IGNORED ) ||
( ps && so->so_vlv > SLAP_CONTROL_IGNORED )) {
/* changed from paged to vlv or vice versa, abandon */
ok = 0;
so->so_nentries = 0;
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
}
if ( ok ) {
/* occupy before mutex unlock */
so->so_running = 1;
}
}
/* Are there too many running overall? */
} else if ( si->svi_num >= si->svi_max ) {
ok = 0;
} else if ( ( sess_id = find_next_session(si->svi_max_percon, op->o_conn->c_conn_idx ) ) < 0 ) {
ok = 0;
} else {
/* OK, this connection going a sort running as the sess_id */
}
if (! ok || so != NULL) {
assert(need_unlock != 0);
ldap_pvt_thread_mutex_unlock( &sort_conns_mutex );
need_unlock = 0;
}
if ( ok ) {
/* If we're a global overlay, this check got bypassed */
if ( !op->ors_limit && limits_check( op, rs )) {
if (need_unlock) {
ldap_pvt_thread_mutex_unlock( &sort_conns_mutex );
need_unlock = 0;
}
if (so)
free_sort_op( op->o_conn, so );
return rs->sr_err;
}
/* are we continuing a VLV search? */
if ( so && vc && vc->vc_context ) {
assert(need_unlock == 0);
so->so_ctrl = sc;
send_list( op, rs, so );
send_result( op, rs, so );
rc = LDAP_SUCCESS;
/* are we continuing a paged search? */
} else if ( so && ps && ps->ps_cookie ) {
assert(need_unlock == 0);
so->so_ctrl = sc;
send_page( op, rs, so );
send_result( op, rs, so );
rc = LDAP_SUCCESS;
} else {
/* Install serversort response callback to handle a new search */
assert(need_unlock != 0);
assert(so == NULL);
so = ch_calloc( 1, sizeof(sort_op));
slap_callback *cb = op->o_tmpcalloc( 1, sizeof(slap_callback),
op->o_tmpmemctx );
LDAP_ENSURE(so != NULL && cb != NULL); /* FIXME: LDAP_OTHER */
cb->sc_response = sssvlv_op_response;
cb->sc_next = op->o_callback;
cb->sc_private = so;
assert(so->so_tree == NULL);
so->so_ctrl = sc;
so->so_info = si;
if ( ps ) {
so->so_paged = op->o_pagedresults;
so->so_page_size = ps->ps_size;
op->o_pagedresults = SLAP_CONTROL_IGNORED;
assert(so->so_page_size != 0);
} else {
if ( vc ) {
so->so_vlv = op->o_ctrlflag[vlv_cid];
assert(so->so_vlv_target == 0);
assert(so->so_vlv_rc == 0);
assert(so->so_vlv != SLAP_CONTROL_NONE);
} else {
assert(so->so_vlv == SLAP_CONTROL_NONE);
}
}
so->so_session = sess_id;
so->so_vlv = op->o_ctrlflag[vlv_cid];
so->so_vcontext = (size_t)so;
assert(so->so_nentries == 0);
op->o_callback = cb;
assert(sess_id >= 0);
so->so_running = 1;
sort_conns[op->o_conn->c_conn_idx][sess_id] = so;
si->svi_num++;
ldap_pvt_thread_mutex_unlock( &sort_conns_mutex );
need_unlock = 0;
}
assert(need_unlock == 0);
} else {
assert(need_unlock == 0);
if ( so && !so->so_nentries ) {
free_sort_op( op->o_conn, so );
} else {
rs->sr_text = "Other sort requests already in progress";
rs->sr_err = LDAP_BUSY;
}
leave:
assert(need_unlock == 0);
rc = rs->sr_err;
send_ldap_result( op, rs );
}
assert(need_unlock == 0);
return rc;
}
// Response to all POST request
// 3 requests are correct :
// - /GetJson --> Receive faust code / Compile Data / Send back jsonInterface
// - /CreateInstance --> Receive factoryIndex / Create instance
// - /DeleteFactory --> Receive factoryIndex / Delete Factory
int Server::answer_post(MHD_Connection *connection, const char *url, const char *upload_data, size_t *upload_data_size, void **con_cls){
struct connection_info_struct *con_info = (connection_info_struct*)*con_cls;
if (0 != *upload_data_size) {
MHD_post_process(con_info->fPostprocessor, upload_data, *upload_data_size);
*upload_data_size = 0;
return MHD_YES;
} else {
if(strcmp(url, "/GetJson") == 0){
if (compile_Data(con_info)) {
return send_page(connection, con_info->fAnswerstring.c_str(), con_info->fAnswerstring.size(), MHD_HTTP_OK, "application/json");
} else {
return send_page(connection, con_info->fAnswerstring.c_str(), con_info->fAnswerstring.size(), MHD_HTTP_BAD_REQUEST, "text/html");
}
}
else if(strcmp(url, "/GetJsonFromKey") == 0){
if (getJsonFromKey(con_info)) {
return send_page(connection, con_info->fAnswerstring.c_str(), con_info->fAnswerstring.size(), MHD_HTTP_OK, "application/json");
} else {
return send_page(connection, con_info->fAnswerstring.c_str(), con_info->fAnswerstring.size(), MHD_HTTP_BAD_REQUEST, "text/html");
}
}
else if(strcmp(url, "/CreateInstance") == 0){
if (createInstance(con_info)) {
return send_page(connection, "", 0, MHD_HTTP_OK, "text/html");
} else {
return send_page(connection, con_info->fAnswerstring.c_str(), con_info->fAnswerstring.size(), MHD_HTTP_BAD_REQUEST, "text/html");
}
}
// else if(strcmp(url, "/DeleteFactory") == 0){
//
// llvm_dsp_factory* toDelete = fAvailableFactories[con_info->fSHAKey];
//
// if (toDelete) {
//
// fAvailableFactories.erase(con_info->fSHAKey);
// deleteSlaveDSPFactory(toDelete);
//
// return send_page(connection, "", 0, MHD_HTTP_OK, "application/html");
// } else {
// return send_page(connection, "", 0, MHD_HTTP_BAD_REQUEST, "text/html");
// }
// }
else if(strcmp(url, "/StartAudio") == 0){
startAudio(con_info->fSHAKey);
return send_page(connection, "", 0, MHD_HTTP_OK, "text/html");
}
else if(strcmp(url, "/StopAudio") == 0){
stopAudio(con_info->fSHAKey);
return send_page(connection, "", 0, MHD_HTTP_OK, "text/html");
}
else{
return send_page(connection, "", 0, MHD_HTTP_BAD_REQUEST, "text/html");
}
}
}
static int
answer_to_connection (void *cls, struct MHD_Connection *connection,
const char *url, const char *method,
const char *version, const char *upload_data,
size_t *upload_data_size, void **con_cls)
{
struct connection_info_struct *con_info = *con_cls;
//printf("method =%s \n",method);
if (NULL == *con_cls)
{
//printf("NuLl=ClS \n");
struct connection_info_struct *con_info;
con_info = malloc (sizeof (struct connection_info_struct));
if (NULL == con_info)
return MHD_NO;
con_info->answerstring = NULL;
if (0 == strcmp (method, "POST"))
{
con_info->postprocessor =
MHD_create_post_processor (connection, POSTBUFFERSIZE,
iterate_post, (void *) con_info);
if (NULL == con_info->postprocessor)
{
free (con_info);
return MHD_NO;
}
con_info->connectiontype = POST;
}
else
con_info->connectiontype = GET;
*con_cls = (void *) con_info;
return MHD_YES;
}
if (0 == strcmp (method, "GET"))
{
char *reply;
reply = malloc (strlen (askpage) + strlen (str) + 1);
if (NULL == reply)
return MHD_NO;
snprintf (reply,strlen (askpage) + strlen (str) + 1,askpage,str);
return send_page (connection,reply);
}
if (0 == strcmp (method, "POST"))
{
int ret;
//char *reply;
//char *str = "open";
//printf("PoSt \n");
//struct MHD_Response *response;
//reply = malloc (strlen (askpage) + strlen (str) + 1);
//if (NULL == reply)
// return MHD_NO;
//snprintf (reply,strlen (askpage) + strlen (str) + 1,askpage,str);
//printf("reply= %s \n",reply);
//struct connection_info_struct *con_info = *con_cls;
if (*upload_data_size != 0)
{
MHD_post_process (con_info->postprocessor, upload_data,
*upload_data_size);
*upload_data_size = 0;
return MHD_YES;
}
else if (NULL != con_info->answerstring)
return send_page (connection, con_info->answerstring);
}
return send_page (connection, errorpage);
}
