void run_interactive_loop(geonames_by_token_func geonames_func, int max_results, process_geoname_id_func process_func) { char q[MAX_QUERY_LENGTH]; debug("Ready to serve\n"); for (;;) { int i; vector_t tokens; geoname_indices_t geonames; if (!fgets(q, sizeof q, stdin)) break; strlower(strtrim(q)); if (!*q) { puts(""); continue; } tokens = strsplit(q, " \t"); geonames = process_query(tokens, max_results, geonames_func); for (i = 0; i != vector_size(geonames); ++i) process_func(geoname_idx(geonames, i)); puts(""); vector_free(tokens); vector_free(geonames); } }
///////////////////////////////////////////////////// //WINHOLDEM RUNTIME ENTRY POINT ///////////////////////////////////////////////////// OHUSER_API double process_message (const char* pmessage, const void* param) { if (pmessage==NULL) { return 0; } if (param==NULL) { return 0; } if (strcmp(pmessage,"state")==0) { holdem_state *state = (holdem_state*) param; if (ClientStarted != true){ initClient(); } return process_state( (holdem_state*)param ); } if (strcmp(pmessage,"query")==0) { // MessageBox(NULL, (LPCSTR) param, "query", MB_OK); return process_query( (const char*)param ); } //pfgws is outdated now, use exportable functions like GetSymbolFromDll etc if (strcmp(pmessage,"pfgws")==0) { // MessageBox(NULL, "pfgws", "MESSAGE", MB_OK); m_pget_winholdem_symbol = (pfgws_t)param; return 0; } if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "load")==0) { if (ClientStarted != true){ initClient(); } // MessageBox(NULL, "event-load", "MESSAGE", MB_OK); } if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "unload")==0) { // MessageBox(NULL, "event-unload", "MESSAGE", MB_OK); } return 0; }
static gboolean execute_find (MuStore *store, MuConfig *opts, GError **err) { char *query_str; MuQuery *oracle; gboolean rv; oracle = get_query_obj(store, err); if (!oracle) return FALSE; query_str = get_query (opts, err); if (!query_str) { mu_query_destroy (oracle); return FALSE; } if (opts->format == MU_CONFIG_FORMAT_XQUERY) rv = print_xapian_query (oracle, query_str, err); else rv = process_query (oracle, query_str, opts, err); mu_query_destroy (oracle); g_free (query_str); return rv; }
gint main (gint argc, gchar **argv) { #ifndef G_THREADS_ENABLED puts("GLib doesn't support threads. exit"); exit(EXIT_FAILURE); #endif g_type_init(); hostname = g_malloc(sizeof(gchar) * 256); if (gethostname(hostname, 255) != 0){ g_printerr("failed to get hostname.\n"); hostname = ""; } parse_args(&argc, &argv); if (argc <= 1){ g_printerr("fts-search [options] HOSTNAME\n\n"); exit(EXIT_FAILURE); } else { g_printerr("%s\n", argv[1]); } GString *input; gchar buf[4096]; size_t sz; guint qnum; gchar *endptr; Query *queries; guint qid; const gchar *str; gchar *ptr; if (!option.quit){ input = g_string_new(""); while((sz = fread(buf, sizeof(gchar), 4096, stdin)) != 0){ g_string_append_len(input, buf, sz); } qnum = 0; queries = NULL; endptr = input->str; while((qid = strtol(endptr, &endptr, 10)) > 0){ endptr = index(endptr, '"'); ptr = index(endptr, '\n'); qnum++; queries = g_realloc(queries, sizeof(Query) * qnum); queries[qnum-1].id = qid; queries[qnum-1].str = g_strndup(endptr, ptr - endptr); endptr = ptr + 1; } } process_query(argv[1], queries, qnum); return 0; }
int main( int argc, char *argv[]) { try { // check command line if (argc != 2 && argc != 3) { std::cerr << "Usage:\n WNXMLConsole <WN_XML_file> [<semantic_features_XML_file>]\n"; return 1; } // init WN std::cerr << "Reading XML...\n"; std::auto_ptr<ML::MultiLog> logger( ML::MultiLog::create( std::cerr, 100)); std::auto_ptr<LibWNXML::WNQuery> wn( new LibWNXML::WNQuery( argv[1], *logger)); wn->writeStats( std::cerr); // init SemFeatures (if appl.) std::auto_ptr<ML_NPro2::SemFeatures> sf( NULL); if (argc == 3) { std::cerr << "Reading SemFeatures...\n"; sf = std::auto_ptr<ML_NPro2::SemFeatures>( new ML_NPro2::SemFeatures( *wn)); std::cerr << sf->readXML( argv[2]) << " pairs read\n"; } // query loop std::cerr << "Type your query, or .h for help, .q to quit\n"; std::string line; while (true) { std::cerr << ">"; std::getline( std::cin, line); if (line == ".q") break; else if (line != "") { try { process_query( *wn, sf.get(), line, std::cout); } catch (const LibWNXML::InvalidPOSException& e) { std::cerr << e.msg() << std::endl; } } } // while (true) } // try { catch (const std::exception& e) { std::cerr << e.what() << std::endl; return 1; } catch (...) { std::cerr << "Unknown exception\n"; return 1; } return 0; }
/** * @brief 主处理函数 * * @return int * @retval **/ int op_query() { int opret = 0; nshead_t *req_head; nshead_t *res_head; ub_buff_t req_buf; ub_buff_t res_buf; in_addr_t req_ip; req_head = (nshead_t *) ub_server_get_read_buf(); res_head = (nshead_t *) ub_server_get_write_buf(); if(NULL == req_head || NULL == res_head) { UB_LOG_FATAL("get req_head[%ld] || res_head[%ld] failed.", (long)req_head, (long)res_head); return -1; } req_buf.buf = (char *)(req_head + 1); req_buf.size = ub_server_get_read_size() - sizeof(nshead_t); res_buf.buf = (char *)(res_head + 1); res_buf.size = ub_server_get_write_size() - sizeof(nshead_t); //设置一些log需要的字段 char ip_str[20]; ip_str[0] = 0; req_ip = ub_server_get_ip(); inet_ntop(AF_INET, &req_ip, ip_str, sizeof(ip_str)); ub_log_setbasic(UB_LOG_REQIP, "%s", ip_str); ub_log_setbasic(UB_LOG_LOGID, "%u", req_head->log_id); ub_log_setbasic(UB_LOG_REQSVR, "%s", req_head->provider); ub_log_setbasic(UB_LOG_SVRNAME, "%s", g_cfg.svr_query.svr_name); ub_log_pushnotice("req_dlen", "%d", req_head->body_len); *res_head = *req_head; strncpy(res_head->provider, req_head->provider, sizeof(res_head->provider)); res_head->body_len = 0; res_head->reserved = 0; //处理查询 struct timeval total_s,total_e; gettimeofday(&total_s, NULL); opret = process_query(req_head, &req_buf, res_head, &res_buf); if(opret != 0){ UB_LOG_WARNING("[function:op_update]>>>process_query failed! errno:%d", opret); return -1; } gettimeofday(&total_e, NULL); ub_log_setbasic(UB_LOG_PROCTIME, "%luus", TIME_US_DIFF(total_s, total_e)); return opret; }
///////////////////////////////////////////////////// // user.dll entry point ///////////////////////////////////////////////////// USERDLL_API double process_message (const char* pmessage, const void* param) { if (pmessage==NULL) { return 0; } if (param==NULL) { return 0; } if (strcmp(pmessage,"state")==0) { holdem_state *state = (holdem_state*) param; // CString s; // s.Format("<%s>\nPOTS: %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\nCOMMON: %d %d %d %d %d\n%d %d %d\n<%s> %d %.2f %d", // state->m_title, // state->m_pot[0], state->m_pot[1], state->m_pot[2], state->m_pot[3], state->m_pot[4], // state->m_pot[5], state->m_pot[6], state->m_pot[7], state->m_pot[8], state->m_pot[9], // state->m_cards[0], state->m_cards[1], state->m_cards[2], state->m_cards[3], state->m_cards[4], // state->m_is_playing, state->m_is_posting, state->m_dealer_chair, // state->m_player[4].m_name, state->m_player[4].m_name_known, state->m_player[4].m_balance, state->m_player[4].m_balance_known); // MessageBox(NULL, s, "state", MB_OK); return process_state( (holdem_state*)param ); } if (strcmp(pmessage,"query")==0) { // MessageBox(NULL, (LPCSTR) param, "query", MB_OK); return process_query( (const char*)param ); } if (strcmp(pmessage,"pfgws")==0) { // MessageBox(NULL, "pfgws", "MESSAGE", MB_OK); p_get_symbol = (p_getsym_t)param; return 0; } if (strcmp(pmessage,"p_send_chat_message")==0) { // MessageBox(NULL, "p_send_chat_message", "MESSAGE", MB_OK); p_send_chat = (p_send_chat_t)param; return 0; } if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "load")==0) { // MessageBox(NULL, "event-load", "MESSAGE", MB_OK); } if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "unload")==0) { // MessageBox(NULL, "event-unload", "MESSAGE", MB_OK); } return 0; }
///////////////////////////////////////////////////// // user.dll entry point ///////////////////////////////////////////////////// USERDLL_API double process_message (const char* pmessage, const void* param) { if (pmessage==NULL) { return 0; } if (param==NULL) { return 0; } if (strcmp(pmessage,"state")==0) { holdem_state *state = (holdem_state*) param; #ifdef OPT_DEMO_OUTPUT CString s; s.Format("<%s>\nPOTS: %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\nCOMMON: %d %d %d %d %d\n%d %d %d\n<%s> %d %.2f %d", state->m_title, state->m_pot[0], state->m_pot[1], state->m_pot[2], state->m_pot[3], state->m_pot[4], state->m_pot[5], state->m_pot[6], state->m_pot[7], state->m_pot[8], state->m_pot[9], state->m_cards[0], state->m_cards[1], state->m_cards[2], state->m_cards[3], state->m_cards[4], state->m_is_playing, state->m_is_posting, state->m_dealer_chair, state->m_player[4].m_name, state->m_player[4].m_name_known, state->m_player[4].m_balance, state->m_player[4].m_balance_known); MessageBox(NULL, s, "state", MB_OK); #endif OPT_DEMO_OUTPUT return process_state( (holdem_state*)param ); } if (strcmp(pmessage,"query")==0) { #ifdef OPT_DEMO_OUTPUT MessageBox(NULL, (LPCSTR) param, "query", MB_OK); #endif OPT_DEMO_OUTPUT return process_query( (const char*)param ); } if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "load")==0) { #ifdef OPT_DEMO_OUTPUT MessageBox(NULL, "event-load", "MESSAGE", MB_OK); #endif OPT_DEMO_OUTPUT } if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "unload")==0) { #ifdef OPT_DEMO_OUTPUT MessageBox(NULL, "event-unload", "MESSAGE", MB_OK); #endif OPT_DEMO_OUTPUT } return 0; }
// ProcessQuery() // Handling the lookup of dll$symbols DLL_IMPLEMENTS double __stdcall ProcessQuery(const char* pquery) { if (!is_connector_enabled()) { std::cout << "connector not enabled" << std::endl; return 0; } if (pquery==NULL) return 0; if (strncmp(pquery,"dll$test",8)==0) { return GetSymbol("random"); } if (GetSymbol("f$loopback_debug") == 1) { return loopback_debug(pquery); } return process_query(pquery); }
void main(int argc,char *argv[]) { FILE *hdd_load; buildSW(); if(argc < 3) printf("No input specified / Invalid Command\n"); else if(argv[1][0] =='-' && argv[1][1]=='i') { hdd_load = fopen("../bin/tree","rb"); if(hdd_load) { fclose(hdd_load); load2mm(); //buildSW(); printf("Tree Built sucessfully\n"); printf("retrieved vlaue:%ld",doc_count); indexer(argc,argv); } else indexer(argc,argv); } else if(argv[1][0] =='-' && argv[1][1]=='s') { hdd_load = fopen("../bin/tree","rb"); if(hdd_load) { fclose(hdd_load); load2mm(); //printf("Tree Built sucessfully\n"); //printf("retrieved vlaue:%ld\n",doc_count); } if(argv[2][0] =='-' && argv[2][1]=='b') process_query_bm25(argc,argv); else process_query(argc,argv); }// -s }
///////////////////////////////////////////////////// //WINHOLDEM RUNTIME ENTRY POINT ///////////////////////////////////////////////////// WHUSER_API double process_message(const char* pmessage, const void* param) { /* * */ if(pmessage==NULL) { gLog.WriteLog(eSeverityError, eCatOHMessages, "pmessage==NULL.. \n"); return 0; } if(param==NULL) { gLog.WriteLog(eSeverityError, eCatOHMessages, "param==NULL.. \n"); return 0; } gLog.WriteLogNoHeading(eSeverityInfo, eCatGeneral, "PROCESS Message.. %s, Param: %s\n", pmessage, (const char*)param); if(strcmp(pmessage,"state")==0) { gLog.WriteLogNoHeading(eSeverityInfo, eCatOHMessages, "PROCESS STATE..\n\tParam: %s\n", (const char*)param); double ret = process_state( (holdem_state*)param ); gLog.WriteLogNoHeading(eSeverityInfo, eCatOHMessages, "PROCESS STATE FINISHED.. %.2f\n", ret); return ret; } if(strcmp(pmessage,"query")==0) { gLog.WriteLogNoHeading(eSeverityInfo, eCatOHMessages, "RUN QUERY..\nParam: %s\n", (const char*)param); double ret = process_query((const char*)param); gLog.WriteLogNoHeading(eSeverityInfo, eCatOHMessages, "PROCESS QUERY FINISHED.. %.2f\n", ret); return ret; } if(strcmp(pmessage,"pfgws")==0) { gVars.m_pget_winholdem_symbol = (pfgws_t)param; return 0; } return 0; }
void Parser::process_input(string _input) { try { // Tokenize the input, divide the string input into minimal units tokenizer.tokenize_input(_input); string token; // Check if there is any token if(tokenizer.remaining_tokens() > 0) { token = tokenizer.peek(); } else { // Most likely blank line, return return; } InputType type = get_input_type(token); switch(type) { case QUERY: process_query(); break; default: process_command(type); break; } } catch(exception& e) { cout << "Exception: " << e.what() << endl; } }
int main(int argc, char *argv[]) { option_t *optList=NULL, *thisOpt=NULL; bool bSqlite, bParam, bTerm, bExact, bDebug, bVersion, bHelp, bError; int countExact = 0; bSqlite = false; bParam = false; bTerm = false; bExact = false; bDebug = false; bVersion = false; bHelp = (argc <= 1); bError = false; tStr sqfn, param = "1", term; /* get list of command line options and their arguments */ optList = GetOptList(argc, argv, (char*)"s:p:t:efdvh"); /* display results of parsing */ while (optList != NULL) { thisOpt = optList; optList = optList->next; switch(thisOpt->option) { case 'v': bVersion = true; break; case 'h': bHelp = true; break; case 'e': bExact = true; countExact++; bError = bError || (countExact > 1); if (countExact > 1) printf("Error: either -e or -f but not both!\n"); break; case 'f': bExact = false; countExact++; bError = bError || (countExact > 1); if (countExact > 1) printf("Error: either -e or -f but not both!\n"); break; case 's': bSqlite = true; process_argwithopt(thisOpt, bError, sqfn, true); break; case 'p': bParam = true; param = thisOpt->argument; break; case 't': bTerm = true; term = thisOpt->argument; break; case 'd': bDebug = true; break; default: break; } free(thisOpt); /* done with this item, free it */ } if (bVersion) { printlicense(); return 0; } if (bHelp || bError) { printhelp(extract_filename(argv[0])); return (bError ? 1 : 0); } if (!bSqlite) { printf("Error: -s is required.\n"); bError = true; } if (!bTerm) { printf("Error: -t is required.\n"); bError = true; } if (bError) { printhelp(extract_filename(argv[0])); return 1; } if (bSqlite && bTerm) { bError = process_query(sqfn, term, param, bExact, bDebug) > 0; } if (bError) { printhelp(extract_filename(argv[0])); } return bError; }
int main(int argc, const char *argv[]) { int ch; size_t diff; long long choice; long long hits; struct resultset rs; char fullpath[MAX_CHOICESIZE]; const char *dirname; const char *errstr; diff = choice = hits = 0; memset(&rs, 0, sizeof(struct resultset)); memset(fullpath, 0, MAX_CHOICESIZE); if (argc < 2) usage(); while ((ch = getopt(argc, (char *const *)argv, "abcd:DiIt:")) != -1) { switch ((char) ch) { case 'a': aflag = 1; cflag = 0; break; case 'b': bflag = 1; break; case 'c': cflag = 1; aflag = 0; break; case 'd': dflag = 1; diff = strtonum(optarg, 0, MAX_HITS, &errstr); if (errstr) errx(1, "You fool, %s is not a NUMBER we " "want! Error: %s", optarg, errstr); break; case 'D': Dflag = 1; Iflag = 0; break; case 'i': iflag = 1; break; case 'I': Iflag = 1; Dflag = 0; break; case 't': tflag = 1; break; default: usage(); } } dirname = argv[optind]; argc -= optind; argv += optind; db_init(); if (cflag) process_query(dirname, dflag); else if (Iflag || Dflag) { int rv = 0; size_t len = 0; char cwd[PATH_MAX]; memset(&cwd, 0, PATH_MAX); if ((getcwd(cwd, sizeof(cwd))) == NULL) { err(5, "Error while retrieving the current path"); goto error; } len = strlen(cwd) + 2; if (len < PATH_MAX) snprintf(cwd, len, "%s/", cwd); else { fprintf(stderr, "path too long\n"); goto error; } if (Iflag && !Dflag) { if ((rv = db_insert_dir(TABLE_HOME, cwd, dirname)) != SQLITE_DONE) { if (rv == SQLITE_CONSTRAINT) fprintf(stderr, "DB already contains %s%s\n", cwd, dirname); else err(1, "Cannot insert directory %s%s to db", cwd, dirname); goto error; } } else if (Dflag) { if ((rv = db_delete_dir(TABLE_HOME, cwd, dirname)) != SQLITE_DONE) { err(1, "Cannot remove directory %s%s from db", cwd, dirname); goto error; } } } else if (aflag) { if (dflag) db_find_spellchecked(TABLE_HOME, dirname, diff); else db_find_exact(TABLE_HOME, dirname); interactive(&choice); rs = db_get_choice_by_id(TABLE_HOME, choice); print_resultset(&rs); } else if (dflag) db_find_spellchecked(TABLE_HOME, dirname, diff); else db_find_exact(TABLE_HOME, dirname); snprintf(fullpath, MAX_CHOICESIZE - 1, "%s%s", rs.path, rs.dir); fullpath[MAX_CHOICESIZE - 1] = '\0'; error: /* Rather close now if we drive to some problem on the next clause */ db_close(); execute(fullpath); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { int c; bool bSqlite, bParam, bTerm, bExact, bFull, bDebug, bVersion, bHelp, bError; int countExact = 0; int limitlen = 80; bSqlite = false; bParam = false; bTerm = false; bExact = false; bFull = false; bDebug = false; bVersion = false; bHelp = (argc <= 1); bError = false; tStr sqfn, param = "1", term; while ((c = getopt2(argc, argv, "s:p:t:l:efudvh")) != -1) { switch(c) { case 'v': bVersion = true; break; case 'h': bHelp = true; break; case 'e': bExact = true; countExact++; bError = bError || (countExact > 1); if (countExact > 1) printf("Error: either -e or -f but not both!\n"); break; case 'f': bExact = false; countExact++; bError = bError || (countExact > 1); if (countExact > 1) printf("Error: either -e or -f but not both!\n"); break; case 's': bSqlite = true; process_argwithopt(optarg, c, bError, sqfn, true); break; case 'p': bParam = true; param = optarg; break; case 't': bTerm = true; term = optarg; break; case 'l': limitlen = atoi(optarg); break; case 'u': bFull = true; break; case 'd': bDebug = true; break; case '?': bError = true; break; default: break; } } if (bVersion) { printlicense(); return 0; } if (bHelp || bError) { printhelp(extract_filename(argv[0])); return (bError ? 1 : 0); } if (!bSqlite) { printf("Error: -s is required.\n"); bError = true; } if (!bTerm) { printf("Error: -t is required.\n"); bError = true; } if (bError) { printhelp(extract_filename(argv[0])); return 1; } if (bSqlite && bTerm) { bError = process_query(sqfn, term, param, bExact, bFull, bDebug, limitlen) > 0; } if (bError) { printhelp(extract_filename(argv[0])); } return bError; }
void tweet_server(void *q) { char *request, *reply, *format, *query; th_args_dt *args = (th_args_dt *)q; tweet_req_dt *tweet_req = (tweet_req_dt *)malloc(sizeof(tweet_req_dt)); tweet_resp_dt *result; /*receive buffer*/ pthread_mutex_lock(&args->th_mutex); request = recv_buf(args->sock); pthread_mutex_unlock(&args->th_mutex); printf("Request received: %s\n",request); char *dup = (char *)malloc(strlen(request)); strcpy(dup,request); char *tmp; tmp = strtok(dup," "); tweet_req->command = tmp; tmp = strtok(NULL," "); tweet_req->handler = atoi(tmp); tmp = strtok(NULL,"\r\n\r\n"); tweet_req->datalength = atoi(tmp); tmp = strtok(NULL,"\0"); tmp = tmp+3*sizeof(char); tweet_req->data = tmp; //printf("Command:%sHandler:%dDatalength:%ldData:%s\n",tweet_req->command, tweet_req->handler, tweet_req->datalength, tweet_req->data); /*LOGIN and SIGNUP request handling*/ if (tweet_req->handler <= 0) {//if the user is asking for login request char *tmp1, *username, *password; tmp1 = strtok(tweet_req->data," "); username = tmp1; tmp1 = strtok(NULL,"\0"); password = tmp1; printf("Received username: %s & password: %s\n",username,password); if (strcmp(tweet_req->command,"LOGIN") == 0) { printf("Login Requested. Authenticating '%s'...\n",username); pthread_mutex_lock(&args->th_mutex); result = login(args->conn,username,password); pthread_mutex_unlock(&args->th_mutex); //printf("%s %d %ld %s\n", result->command,result->st_code, result->dlength,result->data); } else if (strcmp(tweet_req->command,"SIGNUP") == 0) { printf("Signup Requested. Creating user account for '%s'...\n",username); pthread_mutex_lock(&args->th_mutex); result = signup(args->conn,username,password); pthread_mutex_unlock(&args->th_mutex); //printf("%s %d %ld %s\n", result->command,result->st_code, result->dlength,result->data); } } /*other Request Handling*/ else { if (strcmp(tweet_req->command,"LOGOUT") == 0) { printf("LOGOUT Requested. Closing session..."); pthread_mutex_lock(&args->th_mutex); result = logout(args->conn,tweet_req->handler); pthread_mutex_unlock(&args->th_mutex); //printf("%s %d %ld %s\n", result->command,result->st_code, result->dlength,result->data); } else { if (strcmp(tweet_req->command,"FOLLOW") == 0) { printf("FOLLOW requested"); format = "INSERT INTO follow_tb VALUES((SELECT user_id FROM session WHERE ssid= %d),(SELECT user_id FROM users WHERE user_name='%s'))"; query = (char *)malloc(strlen(format)+sizeof(tweet_req->handler)+strlen(tweet_req->data)); bzero(query, sizeof(query)); sprintf(query,format,tweet_req->handler,tweet_req->data); //result = process_query(args->conn, tweet_req->command, query); } else if (strcmp(tweet_req->command,"UNFOLLOW") == 0) { printf("UNFOLLOW requested"); format = "DELETE FROM follow_tb WHERE follower= (SELECT user_id FROM session WHERE ssid=%d) AND following=(SELECT user_id FROM users WHERE user_name=('%s'))"; query = (char *)malloc(strlen(format)+sizeof(tweet_req->handler)+strlen(tweet_req->data)); bzero(query, sizeof(query)); sprintf(query,format,tweet_req->handler,tweet_req->data); //result = process_query(args->conn, tweet_req->command, query); } else if (strcmp(tweet_req->command,"FOLLOWERS") == 0) { printf("FOLLOWERS requested"); format = "SELECT user_name FROM users LEFT JOIN follow_tb ON users.user_id=follow_tb.follower WHERE follow_tb.following=(SELECT user_id FROM session WHERE ssid=(%d))"; query = (char *)malloc(strlen(format)+sizeof(tweet_req->handler)+strlen(tweet_req->data)); bzero(query, sizeof(query)); sprintf(query,format,tweet_req->handler); //result = process_query(args->conn, tweet_req->command, query); } else if (strcmp(tweet_req->command,"FOLLOWING") == 0) { printf("FOLLOWING requested"); format = "SELECT user_name FROM users LEFT JOIN follow_tb ON users.user_id=follow_tb.following WHERE follow_tb.follower=(SELECT user_id FROM session WHERE ssid=(%d))"; query = (char *)malloc(strlen(format)+sizeof(tweet_req->handler)+strlen(tweet_req->data)); bzero(query, sizeof(query)); sprintf(query,format,tweet_req->handler); //result = process_query(args->conn, tweet_req->command, query); } else if (strcmp(tweet_req->command,"TWEET") == 0) { printf("TWEET requested"); format = "INSERT INTO tweets(tweet_text,user_id) VALUES ('%s',(SELECT user_id FROM session WHERE ssid=%d))"; query = (char *)malloc(strlen(format)+sizeof(tweet_req->handler)+strlen(tweet_req->data)); bzero(query, sizeof(query)); sprintf(query,format,tweet_req->data,tweet_req->handler); //result = process_query(args->conn, tweet_req->command, query); } else if (strcmp(tweet_req->command,"UNTWEET") == 0) { printf("UNTWEET requested"); format = "DELETE FROM tweets WHERE tweet_id=%d AND user_id=(SELECT user_id FROM session WHERE ssid=%d)"; query = (char *)malloc(strlen(format)+sizeof(tweet_req->handler)+strlen(tweet_req->data)); bzero(query, sizeof(query)); sprintf(query,format,atoi(tweet_req->data),tweet_req->handler); //result = process_query(args->conn, tweet_req->command, query); } else if (strcmp(tweet_req->command,"ALLTWEETS") == 0) { printf("ALLTWEETS requested"); format = "SELECT tweet_text,tweet_id FROM tweets LEFT JOIN follow_tb ON tweets.user_id = follow_tb.following \ WHERE follow_tb.follower= (SELECT user_id FROM session WHERE ssid=%d) \ UNION SELECT tweet_text,tweet_id FROM tweets WHERE user_id=(SELECT user_id FROM session WHERE ssid=%d)"; query = (char *)malloc(strlen(format)+sizeof(tweet_req->handler)+strlen(tweet_req->data)); bzero(query, sizeof(query)); sprintf(query,format,tweet_req->handler,tweet_req->handler); //result = process_query(args->conn, tweet_req->command, query); } else if (strcmp(tweet_req->command,"MYTWEETS") == 0) { printf("MYTWEETS requested"); format = "SELECT tweet_text,tweet_id FROM tweets WHERE user_id IN (SELECT user_id FROM session WHERE ssid=%d) ORDER BY time_created DESC"; query = (char *)malloc(strlen(format)+sizeof(tweet_req->handler)+strlen(tweet_req->data)); bzero(query, sizeof(query)); sprintf(query,format,tweet_req->handler); //result = process_query(args->conn, tweet_req->command, query); } pthread_mutex_lock(&args->th_mutex); printf("Query:%s\n",query); result = process_query(args->conn, tweet_req->command, query); pthread_mutex_unlock(&args->th_mutex); free(query); }
int main(int argc, char const *argv[]) { // Check args if(argc < 5){ cout << "Please enter (1) a filename query\n \ (2) a csv input file\n \ (3) the number fo results to generate\n\ (4) the number of processes." <<endl; exit(0); } // Check input file FILE *infile = fopen(argv[2], "r"); if(!infile){ cout << "File invalid" << endl; exit(0); } /*************************** Part zero: Get args ****************************/ string queryFilename(argv[1]); // number of results int numResults = 0; if(is_float(argv[3])){ numResults = atoi(argv[3]); } else{ cout << "Invalid number for argument 3" << endl; exit(0); } // number of processes int numProcesses = 0; if(is_float(argv[4])){ numProcesses = atoi(argv[4]); } else{ cout << "Invalid number for argument 4" << endl; exit(0); } /*************************** Part one: Read in file, store in map ****************************/ // Make map of files map< string, uint > fnames; vector< pair< uint, vector<float> > > lines; // Start clock std::chrono::time_point<std::chrono::system_clock> start, end; start = std::chrono::system_clock::now(); int numLines = read_in_file(infile, fnames, lines); end = std::chrono::system_clock::now(); std::chrono::duration<double> timeElapsed1 = end-start; if(numLines <= 0){ cout << "\n\nFile read was unsucessful."<< endl; exit(0); } /*************************** Part two: Perform query ****************************/ start = std::chrono::system_clock::now(); bool success = process_query(fnames, lines, queryFilename, numResults, numProcesses); end = std::chrono::system_clock::now(); std::chrono::duration<double> timeElapsed2 = end-start; if(!success){ cout << "\n\nUnsucessful processing of query" << endl; exit(0); } cout << "\n\nNumber of lines parsed: " << numLines << endl; cout << "Time to process file: " << timeElapsed1.count() << "s" << endl; cout << "Time to process query: " << timeElapsed2.count() << "s" << endl; return 0; }
void do_daemon() { /* do_leap * Main LEAP daemon routine - Contains socket handler */ char buffer[MAXIMUM_INPUT_STRING+1]; char loginname[MAXIMUM_INPUT_STRING+1]; char password[MAXIMUM_INPUT_STRING+1]; char maincommand[MAXIMUM_INPUT_STRING+1]; char tprompt[MAXIMUM_INPUT_STRING+1]; char *result,*tresult,*plogin,*ppass; relation result_relation; int res,startscript=0; int serverSocket=0, on=0, port=0, status=0, childPid=0; struct hostent *hostPtr=NULL; char hostname[80]=""; struct sockaddr_in serverName={0},clientName={0}; struct linger linger={0}; struct utsname sysinfo; int clientLength; tuple ctuple; clientLength=sizeof(clientName); tempdb=LEAPAPI_db_create(NULL,TEMPDB_NAME); res=relations_ddopen(tempdb); if (res!=RETURN_SUCCESS) { raise_error(ERROR_OPEN_DATABASE,FATAL,TEMPDB_NAME); } /* Open the master database */ master_db=LEAPAPI_db_create(NULL,MASTER_DB_NAME); res=relations_ddopen(master_db); if (res!=RETURN_SUCCESS) { raise_error(ERROR_OPEN_DATABASE,FATAL,MASTER_DB_NAME); } if (strlen(dbtoopen)==0) { /* Open up the default user database */ current_db=LEAPAPI_db_create(NULL,DEFAULT_DB); } else { current_db=LEAPAPI_db_create(NULL,dbtoopen); } res=relations_ddopen(current_db); if (res!=RETURN_SUCCESS) { raise_error(ERROR_OPEN_DATABASE,FATAL,database_name(current_db)); } set_variable(VAR_CURRENTDB,database_name(current_db)); /* Check to see if the logins relation exists */ result_relation=relation_find(master_db,LEAP_DD_LOGINS); if (result_relation==NULL) { raise_error(ERROR_CANNOT_FIND_REL,NONFATAL,LEAP_DD_LOGINS); raise_message(MESSAGE,"Building %s",LEAP_DD_LOGINS); /* Build the leaplogins relation */ sprintf(buffer,"(SUID,INTEGER,3),(NAME,string,25),(PASSWORD,string,25),(DEFAULTDB,string,25)"); relation_insert(master_db,create_user_relation(master_db,buffer,LEAP_DD_LOGINS,FALSE,TRUE)); vprocess_query(master_db,"add (%s) (%d,%s,%s,%s)",LEAP_DD_LOGINS,LEAP_SUID_DBA,LEAP_LOGIN_DBA,LEAP_PASS_DBA,MASTER_DB_NAME); } else { raise_message(MESSAGE,"Found %s!",LEAP_DD_LOGINS); } if (status_quiet!=TRUE) { raise_message(MESSAGE,"%s","Startup sequence initiated."); } terminate=FALSE; terminatenow=FALSE; if (status_quiet) { strcpy(current_prompt,""); set_prompt(""); } else { strcpy(current_prompt,DEFAULT_PROMPT); set_prompt(DEFAULT_PROMPT); } if (configuration!=TRUE) { raise_message(MESSAGE,"Sourcing %s%s in %s",LEAP_STARTUP,LEAP_SOURCE_EXT,database_name(master_db)); sprintf(buffer,"%s%s%s%s",database_dir(master_db),LEAP_SOURCE_DIR,LEAP_STARTUP,LEAP_SOURCE_EXT); assign_input_stream(buffer); } else { sprintf(buffer,"%s",configurationfile); assign_input_stream(buffer); } serverSocket=socket(PF_INET,SOCK_STREAM,0); if (serverSocket==-1) { raise_error(ERROR_SOCKETINIT,FATAL,"socket()"); } on=1; status=setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,(const char *) &on,sizeof(on)); if (status==-1) { raise_error(ERROR_SOCKETINIT,FATAL,"setsockopt(...,SO_REUSEADDR,...)"); } linger.l_onoff=1; linger.l_linger=30; status=setsockopt(serverSocket,SOL_SOCKET,SO_LINGER,(const char *) &linger,sizeof(linger)); if (status==-1) { raise_error(ERROR_SOCKETINIT,FATAL,"setsockopt(...,SO_LINGER,...)"); } status=uname(&sysinfo); if (status==-1) { raise_error(ERROR_SOCKETINIT,FATAL,"uname"); } else { strncpy(hostname,sysinfo.nodename,sizeof(hostname)); } status=gethostname(hostname,sizeof(hostname)); hostPtr=gethostbyname(hostname); if (hostPtr==NULL) { raise_error(ERROR_SOCKETINIT,FATAL,"gethostbyname"); } (void) memset(&serverName,0,sizeof(serverName)); (void) memcpy(&serverName.sin_addr,hostPtr->h_addr,hostPtr->h_length); serverName.sin_family=AF_INET; serverName.sin_port=htons(LEAPD_PORT); status=bind(serverSocket,(struct sockaddr *) &serverName,sizeof(serverName)); if (status<0) { raise_error(ERROR_SOCKETINIT,FATAL,"bind() - port %u - errno %u",LEAPD_PORT,errno); } else { raise_message(MESSAGE,"Daemon starting on machine %s, port %u",hostname,LEAPD_PORT); } status=listen(serverSocket,LEAPD_BACK_LOG); if (status==-1) { raise_error(ERROR_SOCKETINIT,FATAL,"listen()"); } while (!terminatenow) { slaveSocket=accept(serverSocket,(struct sockaddr *) &clientName,&clientLength); if (slaveSocket==-1) { raise_error(ERROR_SOCKETINIT,FATAL,"accept()"); } raise_message(MESSAGE,"Connection received from [%s]",inet_ntoa(clientName.sin_addr)); raise_message(MESSAGE,"Authenication expected"); strcpy(buffer,"Please authenticate yourself: "); write(slaveSocket,buffer,strlen(buffer)); read(slaveSocket,loginname,MAXIMUM_INPUT_STRING); plogin=strtok(loginname,"\r\n"); raise_message(MESSAGE,"Login [%s] connecting...",plogin); if (strcmp(plogin,"guest")==0) { strcpy(buffer,"Enter your e-mail address: "); write(slaveSocket,buffer,strlen(buffer)); } else { strcpy(buffer,"Password: "******"project (select (%s) (%s='%s')) (%s)",LEAP_DD_LOGINS,LEAP_DDA_LOGINS_NAME,plogin,LEAP_DDA_LOGINS_PASSWORD); result_relation=process_query(master_db,buffer); status=read(slaveSocket,password,MAXIMUM_INPUT_STRING); ppass=strtok(password,"\r\n"); if ((ppass!=NULL) && (status==2)) { *ppass='******'; } ctuple=tuple_readfirst(result_relation,TUPLE_BUILD,NULL); if (ctuple!=NULL) { tuple_to_string(ctuple,buffer); raise_message(MESSAGE,"Password expected [%s]",buffer); raise_message(MESSAGE,"Password received [%s]",ppass); } else { if (strcmp(plogin,"guest")==0) { raise_message(MESSAGE,"Guest ID [%s]",ppass); } else { raise_message(MESSAGE,"No login [%s] exists!",plogin); } } if (((strcmp(plogin,"guest")==0))||(strcmp(buffer,ppass)==0)) { raise_message(MESSAGE,"Login [%s] validated!",plogin); /* Enable daemon on - this will send io to client */ status_daemon=TRUE; strcpy(buffer,"version"); result_relation=process_query(current_db,buffer); /* Ok, socket is initialised! */ while (!terminate) { write(slaveSocket,DEFAULT_PROMPT,sizeof(DEFAULT_PROMPT)); status=read(slaveSocket,buffer,MAXIMUM_INPUT_STRING); /* Null terminate reqd....*/ result=strtok(buffer,"\r\n"); status_daemon=FALSE; raise_message(MESSAGE,"received: %s",result); status_daemon=TRUE; result_relation=process_query(current_db,result); } /* Disable daemon */ status_daemon=FALSE; } else { raise_message(MESSAGE,"Invalid password for login [%s]",plogin); } /* Reset terminate - one client has disconnected */ terminate=FALSE; raise_message(MESSAGE,"Connection closed"); close(slaveSocket); } if (!status_quiet) { raise_message(MESSAGE,"Closing [%s] database.",database_name(current_db)); } relations_dispose_all(current_db); LEAPAPI_db_destroy(¤t_db); raise_event(EVENT,"[current_db] closed."); if (!status_quiet) { raise_message(MESSAGE,"Closing [%s] database.",database_name(master_db)); } relations_dispose_all(master_db); LEAPAPI_db_destroy(&master_db); raise_event(EVENT,"[master_db] closed."); if (!status_quiet) { raise_message(MESSAGE,"Closing [%s] database.",database_name(tempdb)); } relations_dispose_all(tempdb); LEAPAPI_db_destroy(&tempdb); raise_event(EVENT,"[tempdb] closed."); }
static void *swd_reader(void *arg) { uint32_t data[MAXWORDS]; unsigned query_id; int r; int once = 1; restart: for (;;) { if ((usb = usb_open(0x18d1, 0xdb03, 0))) break; if ((usb = usb_open(0x18d1, 0xdb04, 0))) break; if (once) { xprintf(XSWD, "usb: waiting for debugger device\n"); once = 0; } usleep(250000); } once = 0; xprintf(XSWD, "usb: debugger connected\n"); pthread_mutex_lock(&swd_lock); // send a version query to find out about the firmware // old m3debug fw will just report failure query_id = sequence++; query_id = RSWD_TXN_START(query_id); data[0] = query_id; data[1] = RSWD_MSG(CMD_VERSION, 0, RSWD_VERSION); usb_write(usb, data, 8); for (;;) { pthread_mutex_unlock(&swd_lock); r = usb_read_forever(usb, data, MAXWORDS * 4); pthread_mutex_lock(&swd_lock); if (r < 0) { xprintf(XSWD, "usb: debugger disconnected\n"); swd_online = -1; swd_txn_status = TXN_STATUS_FAIL; pthread_cond_broadcast(&swd_event); break; } if ((r < 4) || (r & 3)) { xprintf(XSWD, "usb: discard packet (%d)\n", r); continue; } if (query_id && (data[0] == query_id)) { query_id = 0; process_query(data + 1, (r / 4) - 1); swd_online = 1; } else if (data[0] == RSWD_TXN_ASYNC) { pthread_mutex_unlock(&swd_lock); process_async(data + 1, (r / 4) - 1); pthread_mutex_lock(&swd_lock); } else if ((swd_txn_status == TXN_STATUS_WAIT) && (data[0] == swd_txn_id)) { swd_txn_status = r; memcpy(swd_txn_data, data, r); pthread_cond_broadcast(&swd_event); } else { xprintf(XSWD, "usb: rx: unexpected txn %08x (%d)\n", data[0], r); } } // wait for a reader to ack the shutdown (and close usb) while (swd_online == -1) { pthread_cond_wait(&swd_event, &swd_lock); } pthread_mutex_unlock(&swd_lock); usleep(250000); goto restart; return NULL; }
void c_debug_handler(frame_context *frame) { char *ptr; s32 addr,len; s32 thread,current_thread; s32 host_has_detached; frame_context *regptr; thread = gdbstub_getcurrentthread(); current_thread = thread; if(current_device->open(current_device)<0) return; if(dbg_active) { gdbstub_report_exception(frame,thread); putpacket(remcomOutBuffer); } if(frame->SRR0==(u32)__breakinst) frame->SRR0 += 4; host_has_detached = 0; while(!host_has_detached) { remcomOutBuffer[0]= 0; getpacket(remcomInBuffer); switch(remcomInBuffer[0]) { case '?': gdbstub_report_exception(frame,thread); break; case 'D': dbg_instep = 0; dbg_active = 0; frame->SRR1 &= ~MSR_SE; strcpy(remcomOutBuffer,"OK"); host_has_detached = 1; break; case 'k': dbg_instep = 0; dbg_active = 0; frame->SRR1 &= ~MSR_SE; frame->SRR0 = 0x80001800; host_has_detached = 1; goto exit; case 'g': regptr = frame; ptr = remcomOutBuffer; if(current_thread!=thread) regptr = ¤t_thread_registers; ptr = mem2hstr(ptr,(char*)regptr->GPR,32*4); ptr = mem2hstr(ptr,(char*)regptr->FPR,32*8); ptr = mem2hstr(ptr,(char*)®ptr->SRR0,4); ptr = mem2hstr(ptr,(char*)®ptr->SRR1,4); ptr = mem2hstr(ptr,(char*)®ptr->CR,4); ptr = mem2hstr(ptr,(char*)®ptr->LR,4); ptr = mem2hstr(ptr,(char*)®ptr->CTR,4); ptr = mem2hstr(ptr,(char*)®ptr->XER,4); ptr = mem2hstr(ptr,(char*)®ptr->FPSCR,4); break; case 'm': ptr = &remcomInBuffer[1]; if(hexToInt(&ptr,&addr) && ((addr&0xC0000000)==0xC0000000 || (addr&0xC0000000)==0x80000000) && *ptr++==',' && hexToInt(&ptr,&len) && len<=((BUFMAX - 4)/2)) mem2hstr(remcomOutBuffer,(void*)addr,len); else strcpy(remcomOutBuffer,"E00"); break; case 'q': process_query(remcomInBuffer,remcomOutBuffer,thread); break; case 'c': dbg_instep = 0; dbg_active = 1; frame->SRR1 &= ~MSR_SE; current_device->wait(current_device); goto exit; case 's': dbg_instep = 1; dbg_active = 1; frame->SRR1 |= MSR_SE; current_device->wait(current_device); goto exit; case 'z': { s32 ret,type,len; char *addr; ret = parsezbreak(remcomInBuffer,&type,&addr,&len); if(!ret) { strcpy(remcomOutBuffer,"E01"); break; } if(type!=0) break; if(len<4) { strcpy(remcomOutBuffer,"E02"); break; } ret = remove_bp(addr); if(!ret) { strcpy(remcomOutBuffer,"E03"); break; } strcpy(remcomOutBuffer,"OK"); } break; case 'H': if(remcomInBuffer[1]=='g') { s32 tmp,ret; if(vhstr2thread(&remcomInBuffer[2],&tmp)==NULL) { strcpy(remcomOutBuffer,"E01"); break; } if(!tmp) tmp = thread; if(tmp==current_thread) { strcpy(remcomOutBuffer,"OK"); break; } if(current_thread!=thread) ret = gdbstub_setthreadregs(current_thread,¤t_thread_registers); if(tmp!=thread) { ret = gdbstub_getthreadregs(tmp,¤t_thread_registers); if(!ret) { strcpy(remcomOutBuffer,"E02"); break; } } current_thread= tmp; } strcpy(remcomOutBuffer,"OK"); break; case 'T': { s32 tmp; if(vhstr2thread(&remcomInBuffer[1],&tmp)==NULL) { strcpy(remcomOutBuffer,"E01"); break; } if(gdbstub_indextoid(tmp)==NULL) strcpy(remcomOutBuffer,"E02"); else strcpy(remcomOutBuffer,"OK"); } break; case 'Z': { s32 ret,type,len; char *addr; ret = parsezbreak(remcomInBuffer,&type,&addr,&len); if(!ret) { strcpy(remcomOutBuffer,"E01"); break; } if(type!=0) { strcpy(remcomOutBuffer,"E02"); break; } if(len<4) { strcpy(remcomOutBuffer,"E03"); break; } ret = insert_bp(addr); if(!ret) { strcpy(remcomOutBuffer,"E04"); break; } strcpy(remcomOutBuffer,"OK"); } break; } putpacket(remcomOutBuffer); } current_device->close(current_device); exit: return; }
int main(int argc, char **argv) { char *inquery=NULL, *inip=NULL; char *inmethod=NULL, *inpath=NULL; int port=0, cgi=0; thread_data_p tdata; setup_globals(); // set globalptr and its components // Set up abnormal termination handler to clear locks #ifdef CATCH_SIGNALS signal(SIGSEGV,termination_handler); signal(SIGFPE,termination_handler); signal(SIGABRT,termination_handler); signal(SIGTERM,termination_handler); signal(SIGINT,termination_handler); signal(SIGILL,termination_handler); #endif #if _MSC_VER // some signals not used in windows #else signal(SIGPIPE,SIG_IGN); // important for TCP/IP handling #endif // detect calling parameters // process environment and args inmethod=getenv("REQUEST_METHOD"); if (inmethod!=NULL) { // assume cgi call cgi=1; inip=getenv("REMOTE_ADDR"); #ifdef CONF_FILE inpath=CONF_FILE; #endif } else { #ifdef SERVEROPTION if (argc<=1) { // no params #ifdef DEFAULT_PORT // use as server by default port=DEFAULT_PORT; #else print_help(); exit(0); #endif } else if (argc>1) { // command line param given inquery=argv[1]; if (!strcmp(inquery,HELP_PARAM)) { print_help(); exit(0); } port=atoi(inquery); // 0 port means no server if (argc>2) { // conf file given inpath=argv[2]; } } // run either as a server or a command line/cgi program if (port) { #ifdef CONF_FILE if (inpath==NULL) inpath=CONF_FILE; #endif if (inpath!=NULL) { // process conf file load_configuration(inpath,globalptr->conf); //print_conf(globalptr->conf); } run_server(port,globalptr); return 0; } #else if (argc>1) { // command line param given inquery=argv[1]; if (argc>2) { // conf file given inpath=argv[2]; } else { #ifdef CONF_FILE inpath=CONF_FILE; #endif } } else { // no params given print_help(); exit(0); } #endif } if (!port) { // run as command line or cgi #if _MSC_VER // no alarm on windows #else // a timeout for cgi/command line signal(SIGALRM,timeout_handler); alarm(TIMEOUT_SECONDS); #endif if (inpath!=NULL) { // process conf file load_configuration(inpath,globalptr->conf); //print_conf(globalptr->conf); } // setup a single tdata block globalptr->maxthreads=1; tdata=&(globalptr->threads_data[0]); tdata->isserver=0; tdata->iscgi=cgi; tdata->ip=inip; tdata->port=0; tdata->method=0; tdata->realthread=0; tdata->format=1; tdata->global=globalptr; tdata->inbuf=NULL; tdata->intype=0; tdata->common=NULL; if (cgi) inquery=get_cgi_query(tdata,inmethod); // actual processing process_query(inquery,tdata); return 0; } return 0; }
int main(void) { int i; char inbuf[80]; char *key, *value; int status; employee temporary_record; int week; int blank_line = 1; int query = 0; // Store of all employee data employee employee_list[NUMBER_OF_EMPLOYEES]; for( i=0; i<NUMBER_OF_EMPLOYEES; i++) { initialize_employee(&employee_list[i]); } initialize_employee(&temporary_record); week = 0; // Process input and respond to queries until a blank line is received while(1) { // Read input from network in the form of key-value pairs status = get_key_value((char *)&inbuf, sizeof(inbuf), &key, &value); switch (status) { case READ_ERROR: print("ERROR: on receive\n"); _terminate(1); break; case NEWLINE_RECEIVED: // Process the input line by merging the temporary record with the global record if (blank_line == 1) { print("Exiting\n"); _terminate(0); } if (query > 0) { process_query(query, (employee *)&employee_list, &temporary_record, week); } else if ((temporary_record.id >= 0) && (temporary_record.id < NUMBER_OF_EMPLOYEES)) { merge_employee_records(&employee_list[temporary_record.id], &temporary_record); } // Get ready to process a new line initialize_employee(&temporary_record); week = 0; blank_line = 1; query = 0; break; case KEY_VALUE_RECEIVED: // If this is a query line remember it for processing later if ((blank_line == 1) && (equals(key, "query"))) { if (equals(value, "all")) query = QUERY_ALL; else if (equals(value, "one")) query = QUERY_ONE; else if (equals(value, "week")) query = QUERY_WEEK; else if (equals(value, "week_all")) query = QUERY_WEEK_ALL; else query = 0; } blank_line = 0; // Add the key_value information to a temporary record process_key_value(&temporary_record, key, value, &week); break; case OTHER_INPUT_RECEIVED: default: print("ERROR: invalid input\n"); _terminate(1); break; } } }
static int dnsproxy(unsigned short local_port, const char* remote_addr, unsigned short remote_port, int remote_tcp) { int maxfd, fds; fd_set readfds; struct timeval timeout; struct sockaddr_in addr; time_t current, last_clean; #ifdef _WIN32 BOOL bNewBehavior = FALSE; DWORD dwBytesReturned = 0; #endif PROXY_ENGINE *engine = &g_engine; LOCAL_DNS *ldns = &engine->local; REMOTE_DNS *rdns = &engine->remote; ldns->sock = socket(AF_INET, SOCK_DGRAM, 0); if(ldns->sock == INVALID_SOCKET) { perror("create socket"); return -1; } setsockopt(ldns->sock, SOL_SOCKET, SO_REUSEADDR, (char*)&enable, sizeof(enable)); #ifdef _WIN32 WSAIoctl(ldns->sock, SIO_UDP_CONNRESET, &bNewBehavior, sizeof(bNewBehavior), NULL, 0, &dwBytesReturned, NULL, NULL); #endif memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = INADDR_ANY; addr.sin_port = htons(local_port); if(bind(ldns->sock, (struct sockaddr*)&addr, sizeof(addr)) != 0) { perror("bind service port"); return -1; } rdns->tcp = remote_tcp; rdns->sock = INVALID_SOCKET; rdns->addr.sin_family = AF_INET; rdns->addr.sin_addr.s_addr = inet_addr(remote_addr); rdns->addr.sin_port = htons(remote_port); rdns->head = 0; rdns->rear = 0; rdns->capacity = sizeof(rdns->buffer); if(!rdns->tcp) { rdns->sock = socket(AF_INET, SOCK_DGRAM, 0); if(rdns->sock == INVALID_SOCKET) { perror("create socket"); return -1; } #ifdef _WIN32 WSAIoctl(rdns->sock, SIO_UDP_CONNRESET, &bNewBehavior, sizeof(bNewBehavior), NULL, 0, &dwBytesReturned, NULL, NULL); #endif } last_clean = time(¤t); while(1) { FD_ZERO(&readfds); FD_SET(ldns->sock, &readfds); maxfd = (int)ldns->sock; if(rdns->sock != INVALID_SOCKET) { FD_SET(rdns->sock, &readfds); if(maxfd < (int)rdns->sock) maxfd = (int)rdns->sock; } timeout.tv_sec = CACHE_CLEAN_TIME; timeout.tv_usec = 0; fds = select(maxfd + 1, &readfds, NULL, NULL, &timeout); if(fds > 0) { if(rdns->sock != INVALID_SOCKET && FD_ISSET(rdns->sock, &readfds)) { if(rdns->tcp) process_response_tcp(rdns); else process_response_udp(rdns); } if(FD_ISSET(ldns->sock, &readfds)) process_query(engine); } if(time(¤t) - last_clean > CACHE_CLEAN_TIME || fds == 0) { last_clean = current; domain_cache_clean(current); transport_cache_clean(current); } } return 0; }
static void process_skb(struct sk_buff *oskb) { int ulen, len, dnslen; struct sk_buff *nskb; struct iphdr *oiph, *niph; struct udphdr *oudph, *nudph, _oudph; struct dnshdr *dnsh; oiph = ip_hdr(oskb); oudph = skb_header_pointer(oskb, ip_hdrlen(oskb), sizeof(_oudph), &_oudph); if (oudph == NULL) { PR_ERR("Invalid UDP packet, dropped"); return; } /* * 5 is the minimal question length * (1 byte root, 2 bytes each type and class) */ dnslen = ntohs(oudph->len) - sizeof(struct udphdr); if (dnslen < sizeof(struct dnshdr) + 5) { PR_ERR("Incomplete DNS packet, dropped"); return; } dnsh = (struct dnshdr *) ((unsigned char *) oudph + sizeof(struct udphdr)); ulen = sizeof(struct udphdr) + MAX_DNS_PACKET_LEN; nskb = alloc_skb(LL_MAX_HEADER + sizeof(struct iphdr) + ulen, GFP_ATOMIC); if (nskb == NULL) { PR_CRIT("alloc_skb failed, dropped"); return; } skb_reserve(nskb, LL_MAX_HEADER + sizeof(struct iphdr) + sizeof(struct udphdr)); len = process_query(oiph, oudph, dnsh, dnslen, nskb->data); if (len < 0) { kfree_skb(nskb); PR_CRIT("process dns query failed, dropped"); return; } nskb->len += len; nudph = (struct udphdr *) skb_push(nskb, sizeof(struct udphdr)); skb_reset_transport_header(nskb); ulen = sizeof(struct udphdr) + len; nudph->source = oudph->dest; nudph->dest = oudph->source; nudph->len = htons(ulen); nudph->check = 0; nudph->check = csum_tcpudp_magic(oiph->daddr, oiph->saddr, ulen, IPPROTO_UDP, csum_partial(nudph, ulen, 0)); if (nudph->check == 0) { nudph->check = CSUM_MANGLED_0; } niph = (struct iphdr *) skb_push(nskb, sizeof(struct iphdr)); skb_reset_network_header(nskb); /* niph->version = 4; niph->ihl = 5; */ put_unaligned(0x45, (unsigned char *) niph); niph->tos = 0; put_unaligned(htons(nskb->len), &(niph->tot_len)); niph->id = 0x8659; /* birthday of my wife ^o^ */ niph->frag_off = htons(IP_DF); niph->ttl = 64; niph->protocol = IPPROTO_UDP; niph->check = 0; put_unaligned(oiph->daddr, &(niph->saddr)); put_unaligned(oiph->saddr, &(niph->daddr)); ip_send_check(niph); skb_dst_set(nskb, dst_clone(skb_dst(oskb))); if (ip_route_me_harder(nskb, RTN_LOCAL)) { goto free_nskb; } nf_ct_attach(nskb, oskb); ip_local_out(nskb); return; free_nskb: kfree_skb(nskb); }
///////////////////////////////////////////////////// // user.dll entry point ///////////////////////////////////////////////////// USERDLL_API double process_message (const char* pmessage, const void* param) { if (pmessage==NULL) { return 0; } inHandMsgNum++; isAllInMsg = false; //ensure files open if (!dumpOutFile.is_open()) { //read config getConfigValue("dumpOutFileName", dumpOutFileName); getConfigValue("testfilesDir", testfilesDir); dumpOutFile.open(dumpOutFileName.c_str()); initTestFilenameList(); } if (strcmp(pmessage,"state")==0) { std::cout << "process_message called with state" << std::endl; holdem_state *state = (holdem_state*) param; // CString s; // s.Format("<%s>\nPOTS: %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\nCOMMON: %d %d %d %d %d\n%d %d %d\n<%s> %d %.2f %d", // state->m_title, // state->m_pot[0], state->m_pot[1], state->m_pot[2], state->m_pot[3], state->m_pot[4], // state->m_pot[5], state->m_pot[6], state->m_pot[7], state->m_pot[8], state->m_pot[9], // state->m_cards[0], state->m_cards[1], state->m_cards[2], state->m_cards[3], state->m_cards[4], // state->m_is_playing, state->m_is_posting, state->m_dealer_chair, // state->m_player[4].m_name, state->m_player[4].m_name_known, state->m_player[4].m_balance, state->m_player[4].m_balance_known); // MessageBox(NULL, s, "state", MB_OK); return process_state( (holdem_state*)param ); } if (strcmp(pmessage,"query")==0) { std::cout << "process_message called with query " << (const char*) param << std::endl; // MessageBox(NULL, (LPCSTR) param, "query", MB_OK); return process_query( (const char*)param ); } if (strcmp(pmessage,"pfgws")==0) { // MessageBox(NULL, "pfgws", "MESSAGE", MB_OK); p_get_symbol = (p_getsym_t)param; return 0; } if (strcmp(pmessage,"p_send_chat_message")==0) { // MessageBox(NULL, "p_send_chat_message", "MESSAGE", MB_OK); p_send_chat = (p_send_chat_t)param; return 0; } if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "load")==0) { // MessageBox(NULL, "event-load", "MESSAGE", MB_OK); } if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "unload")==0) { // MessageBox(NULL, "event-unload", "MESSAGE", MB_OK); } return 0; }