int main( int argc, char **argv) { OPEN_LOG("check_signature", LOG_USER); if (argc != 3) FATAL(MSG_USAGE); struct Certificate locert, hicert; struct CertificateRevocationList crl; Certificate(&locert, (ushort) 0); Certificate(&hicert, (ushort) 0); CertificateRevocationList(&crl, (ushort) 0); struct Blob blob; Blob(&blob, (ushort) 0); struct casn *tbsp, *sigp; struct AlgorithmIdentifier *algp; char *sfx = strchr(argv[1], (int)'.'); int ansr; if (!strcmp(sfx, ".cer")) { tbsp = &locert.toBeSigned.self; algp = &locert.algorithm; sigp = &locert.signature; ansr = get_casn_file(&locert.self, argv[1], 0); } else if (!strcmp(sfx, ".crl")) { tbsp = &crl.toBeSigned.self; algp = &crl.algorithm; sigp = &crl.signature; ansr = get_casn_file(&crl.self, argv[1], 0); } else if (!strcmp(sfx, ".blb")) { tbsp = &blob.toBeSigned; algp = &blob.algorithm; sigp = &blob.signature; ansr = get_casn_file(&blob.self, argv[1], 0); } else FATAL(MSG_TYPE, argv[1]); if (ansr < 0) FATAL(MSG_GET, argv[1]); if (get_casn_file(&hicert.self, argv[2], 0) < 0) FATAL(MSG_GET, argv[2]); if (diff_objid(&algp->algorithm, id_sha_256WithRSAEncryption)) { char oidbuf[80]; read_objid(&algp->algorithm, oidbuf); FATAL(MSG_ALG, oidbuf); } if (!check_signature(tbsp, &hicert, sigp)) fprintf(stderr, "Signature failed\n"); fprintf(stderr, "Signature succeeded\n"); return 0; }
int main(int argc, char *argv[]){ struct file_records_t file_records; if ( argc > 2 ){ char logname[50]; sprintf(logname, "%s%s%s.log", CLIENT_LOG, DEST, argv[2]); OPEN_LOG(logname, DEST, atoi(argv[2])); file_records.vfs_path = argv[1]; int err = get_all_files_from_dbtable(DB_PATH, DEST, &file_records); if ( err != 0 ) return 1; } else{ printf("usage: 1st arg: should be path to VFS folder, 2nd: unique node integer id\n");fflush(0); return 1; } int nodeid = atoi(argv[2]); WRITE_FMT_LOG(LOG_UI, "[%d] Destination node started", nodeid); BigArrayPtr unsorted_array = NULL; BigArrayPtr sorted_array = NULL; unsorted_array = malloc( ARRAY_ITEMS_COUNT*sizeof(BigArrayItem) ); struct file_record_t* ranges_r_record = match_file_record_by_fd( &file_records, DEST_FD_READ_SORTED_RANGES_REP); struct file_record_t* ranges_w_record = match_file_record_by_fd( &file_records, DEST_FD_WRITE_SORTED_RANGES_REP); assert(ranges_r_record); assert(ranges_w_record); repreq_read_sorted_ranges( ranges_r_record->fpath, ranges_w_record->fpath, nodeid, unsorted_array, ARRAY_ITEMS_COUNT, SRC_NODES_COUNT ); sorted_array = alloc_merge_sort( unsorted_array, ARRAY_ITEMS_COUNT ); /*save sorted array to output file*/ char outputfile[100]; memset(outputfile, '\0', 100); sprintf(outputfile, DEST_FILE_FMT, nodeid ); int destfd = open(outputfile, O_WRONLY|O_CREAT); if ( destfd >= 0 ){ const size_t data_size = sizeof(BigArrayItem)*ARRAY_ITEMS_COUNT; if ( sorted_array ){ const ssize_t wrote = write(destfd, sorted_array, data_size); assert(wrote == data_size ); } close(destfd); } struct file_record_t* results_w_record = match_file_record_by_fd( &file_records, DEST_FD_WRITE_SORT_RESULT); assert(results_w_record); write_sort_result( results_w_record->fpath, nodeid, sorted_array, ARRAY_ITEMS_COUNT ); free(unsorted_array); WRITE_FMT_LOG(LOG_UI, "[%d] Destination node complete", nodeid); }
int main(int argc, char **argv) { int ret_val = 0; int verify; key_metainfo_t *info = NULL; char *char_msg = "My msg"; bytes_t *signature; OPEN_LOG(); LOG(LOG_LVL_NOTI, "Logger started for %s", argv[0]); dtc_ctx_t *ctx = dtc_init(NULL, &ret_val); printf("Init ret: %d:%s\n", ret_val, dtc_get_error_msg(ret_val)); if(ret_val != DTC_ERR_NONE) return 1; ret_val = dtc_generate_key_shares(ctx, "hola_id", 512, 2, 2, NULL, &info); printf("Generate: %d:%s\n", ret_val, dtc_get_error_msg(ret_val)); if(ret_val != DTC_ERR_NONE) { printf("Destroy: %d\n", dtc_destroy(ctx)); return 1; } bytes_t *msg = tc_init_bytes((void *)char_msg, strlen(char_msg)); bytes_t *prep_msg = tc_prepare_document(msg, TC_SHA256, info); ret_val = dtc_sign(ctx, info, "hola_id", prep_msg, &signature); printf("Sign: %d: %s\n", ret_val, dtc_get_error_msg(ret_val)); if(ret_val == DTC_ERR_NONE) { verify = tc_rsa_verify(signature, msg, info, TC_SHA256); printf("Verify: %d\n", verify); tc_clear_bytes(signature); if(verify != 1) { return 1; } } tc_clear_key_metainfo(info); tc_clear_bytes(prep_msg); free(msg); dtc_delete_key_shares(ctx, "hola_id"); printf("Destroy: %d\n", dtc_destroy(ctx)); return ret_val != DTC_ERR_NONE; }
int main( int argc, char **argv) { OPEN_LOG("cert_validate", LOG_USER); if (argc != 3) FATAL(MSG_USAGE); struct Certificate locert, hicert; Certificate(&locert, (ushort) 0); Certificate(&hicert, (ushort) 0); if (get_casn_file(&locert.self, argv[1], 0) < 0) FATAL(MSG_GET, argv[1]); if (get_casn_file(&hicert.self, argv[2], 0) < 0) FATAL(MSG_GET, argv[2]); if (!check_cert_signature(&locert, &hicert)) FATAL(MSG_SIG, "Failed"); DONE(MSG_SIG, "succeeded"); return 0; }
int main(int argc, char *argv[]) #endif { char *temp, *message; unsigned long t1 = 0, t2 = 0, xid = 0; unsigned long start = 0, lease; fd_set rfds; int fd, retval; struct timeval tv; int c, len; struct ifreq ifr; struct dhcpMessage packet; struct in_addr temp_addr; int pid_fd; static struct option options[] = { {"clientid", required_argument, 0, 'c'}, {"foreground", no_argument, 0, 'f'}, {"hostname", required_argument, 0, 'H'}, {"help", no_argument, 0, 'h'}, {"interface", required_argument, 0, 'i'}, {"now", no_argument, 0, 'n'}, {"pidfile", required_argument, 0, 'p'}, {"quit", no_argument, 0, 'q'}, {"request", required_argument, 0, 'r'}, {"script", required_argument, 0, 's'}, {"version", no_argument, 0, 'v'}, {0, 0, 0, 0} }; /* get options */ while (1) { int option_index = 0; // brcm c = getopt_long(argc, argv, "c:fH:hi:np:qr:s:d:v", options, &option_index); if (c == -1) break; switch (c) { case 'c': len = strlen(optarg) > 255 ? 255 : strlen(optarg); if (client_config.clientid) free(client_config.clientid); client_config.clientid = malloc(len + 2); client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID; client_config.clientid[OPT_LEN] = len; strncpy(client_config.clientid + 2, optarg, len); break; case 'f': client_config.foreground = 1; break; case 'H': len = strlen(optarg) > 255 ? 255 : strlen(optarg); if (client_config.hostname) free(client_config.hostname); client_config.hostname = malloc(len + 2); client_config.hostname[OPT_CODE] = DHCP_HOST_NAME; client_config.hostname[OPT_LEN] = len; strncpy(client_config.hostname + 2, optarg, len); break; case 'h': print_usage(); return 0; case 'i': client_config.interface = optarg; // brcm strcpy(session_path, optarg); break; case 'n': client_config.abort_if_no_lease = 1; break; case 'p': client_config.pidfile = optarg; break; case 'q': client_config.quit_after_lease = 1; break; case 'r': requested_ip = inet_addr(optarg); break; // brcm case 'd': strcpy(vendor_class_id, optarg); break; case 's': client_config.script = optarg; break; case 'v': printf("udhcpcd, version %s\n\n", VERSION); break; } } // brcm if (strlen(session_path) > 0) { sprintf(status_path, "%s/%s/%s", _PATH_WAN_DIR, session_path, _PATH_MSG); sprintf(pid_path, "%s/%s/%s", _PATH_WAN_DIR, session_path, _PATH_PID); } OPEN_LOG("udhcpc"); LOG(LOG_INFO, "udhcp client (v%s) started", VERSION); pid_fd = pidfile_acquire(client_config.pidfile); pidfile_write_release(pid_fd); if ((fd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) >= 0) { strcpy(ifr.ifr_name, client_config.interface); if (ioctl(fd, SIOCGIFINDEX, &ifr) == 0) { DEBUG(LOG_INFO, "adapter index %d", ifr.ifr_ifindex); client_config.ifindex = ifr.ifr_ifindex; } else { LOG(LOG_ERR, "SIOCGIFINDEX failed! %s", strerror(errno)); exit_client(1); } if (ioctl(fd, SIOCGIFHWADDR, &ifr) == 0) { memcpy(client_config.arp, ifr.ifr_hwaddr.sa_data, 6); DEBUG(LOG_INFO, "adapter hardware address %02x:%02x:%02x:%02x:%02x:%02x", client_config.arp[0], client_config.arp[1], client_config.arp[2], client_config.arp[3], client_config.arp[4], client_config.arp[5]); } else { LOG(LOG_ERR, "SIOCGIFHWADDR failed! %s", strerror(errno)); exit_client(1); } } else { LOG(LOG_ERR, "socket failed! %s", strerror(errno)); exit_client(1); } close(fd); fd = -1; /* setup signal handlers */ signal(SIGUSR1, renew_requested); signal(SIGUSR2, release_requested); signal(SIGTERM, terminate); state = INIT_SELECTING; // brcm // run_script(NULL, "deconfig"); // brcm setStatus(0); for (;;) { // brcm if ((old_mode != listen_mode) || (fd == -1)) { old_mode = listen_mode; if (fd > 0) { close(fd); fd = -1; } if (listen_mode == LISTEN_RAW) { if ((fd = raw_socket(client_config.ifindex)) < 0) { LOG(LOG_ERR, "couldn't create raw socket -- au revoir"); exit_client(0); } } else if (listen_mode == LISTEN_KERNEL) { if ((fd = listen_socket(INADDR_ANY, CLIENT_PORT, client_config.interface)) < 0) { LOG(LOG_ERR, "couldn't create server socket -- au revoir"); exit_client(0); } } else fd = -1; } tv.tv_sec = timeout - time(0); tv.tv_usec = 0; FD_ZERO(&rfds); if (listen_mode) FD_SET(fd, &rfds); if (tv.tv_sec > 0) { retval = select(fd + 1, &rfds, NULL, NULL, &tv); } else retval = 0; /* If we already timed out, fall through */ if (retval == 0) { /* timeout dropped to zero */ switch (state) { case INIT_SELECTING: // brcm setStatus(0); if (packet_num < 3) { if (packet_num == 0) xid = random_xid(); /* send discover packet */ send_discover(xid, requested_ip); /* broadcast */ timeout = time(0) + ((packet_num == 2) ? 10 : 2); packet_num++; } else { if (client_config.abort_if_no_lease) { LOG(LOG_INFO, "No lease, failing."); exit_client(1); } /* wait to try again */ packet_num = 0; timeout = time(0) + 60; } break; case RENEW_REQUESTED: case REQUESTING: if (packet_num < 3) { /* send request packet */ if (state == RENEW_REQUESTED) send_renew(xid, server_addr, requested_ip); /* unicast */ else send_selecting(xid, server_addr, requested_ip); /* broadcast */ timeout = time(0) + ((packet_num == 2) ? 10 : 2); packet_num++; } else { /* timed out, go back to init state */ state = INIT_SELECTING; timeout = time(0); packet_num = 0; listen_mode = LISTEN_RAW; } break; case BOUND: /* Lease is starting to run out, time to enter renewing state */ state = RENEWING; listen_mode = LISTEN_KERNEL; DEBUG(LOG_INFO, "Entering renew state"); /* fall right through */ case RENEWING: /* Either set a new T1, or enter REBINDING state */ if ((t2 - t1) <= (lease / 14400 + 1)) { /* timed out, enter rebinding state */ state = REBINDING; timeout = time(0) + (t2 - t1); DEBUG(LOG_INFO, "Entering rebinding state"); } else { /* send a request packet */ send_renew(xid, server_addr, requested_ip); /* unicast */ t1 = (t2 - t1) / 2 + t1; timeout = t1 + start; } break; case REBINDING: /* Either set a new T2, or enter INIT state */ if ((lease - t2) <= (lease / 14400 + 1)) { /* timed out, enter init state */ state = INIT_SELECTING; LOG(LOG_INFO, "Lease lost, entering init state"); run_script(NULL, "deconfig"); timeout = time(0); packet_num = 0; listen_mode = LISTEN_RAW; } else { /* send a request packet */ send_renew(xid, 0, requested_ip); /* broadcast */ t2 = (lease - t2) / 2 + t2; timeout = t2 + start; } break; case RELEASED: /* yah, I know, *you* say it would never happen */ timeout = 0xffffffff; break; } } else if (retval > 0 && listen_mode != LISTEN_NONE && FD_ISSET(fd, &rfds)) { /* a packet is ready, read it */ if (listen_mode == LISTEN_KERNEL) { if (get_packet(&packet, fd) < 0) continue; } else { if (get_raw_packet(&packet, fd) < 0) continue; } if (packet.xid != xid) { DEBUG(LOG_INFO, "Ignoring XID %lx (our xid is %lx)", (unsigned long) packet.xid, xid); continue; } if ((message = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) { DEBUG(LOG_ERR, "couldnt get option from packet -- ignoring"); continue; } switch (state) { case INIT_SELECTING: /* Must be a DHCPOFFER to one of our xid's */ if (*message == DHCPOFFER) { if ((temp = get_option(&packet, DHCP_SERVER_ID))) { memcpy(&server_addr, temp, 4); xid = packet.xid; requested_ip = packet.yiaddr; /* enter requesting state */ state = REQUESTING; timeout = time(0); packet_num = 0; } else { DEBUG(LOG_ERR, "No server ID in message"); } } break; case RENEW_REQUESTED: case REQUESTING: case RENEWING: case REBINDING: if (*message == DHCPACK) { if (!(temp = get_option(&packet, DHCP_LEASE_TIME))) { LOG(LOG_ERR, "No lease time with ACK, using 1 hour lease"); lease = 60*60; } else { memcpy(&lease, temp, 4); lease = ntohl(lease); } /* enter bound state */ t1 = lease / 2; /* little fixed point for n * .875 */ t2 = (lease * 0x7) >> 3; temp_addr.s_addr = packet.yiaddr; LOG(LOG_INFO, "Lease of %s obtained, lease time %ld", inet_ntoa(temp_addr), lease); start = time(0); timeout = t1 + start; requested_ip = packet.yiaddr; run_script(&packet, ((state == RENEWING || state == REBINDING) ? "renew" : "bound")); state = BOUND; listen_mode = LISTEN_NONE; // brcm setStatus(1); background(); } else if (*message == DHCPNAK) { /* return to init state */ LOG(LOG_INFO, "Received DHCP NAK"); if (state != REQUESTING) run_script(NULL, "deconfig"); state = INIT_SELECTING; timeout = time(0); requested_ip = 0; packet_num = 0; listen_mode = LISTEN_RAW; // brcm setStatus(0); } break; case BOUND: case RELEASED: /* ignore all packets */ break; } } else if (retval == -1 && errno == EINTR) {
int main( int argc, char **argv) { int ret = EXIT_SUCCESS; bool done_db_init = false; bool done_db_thread_init = false; dbconn * db = NULL; bool first_time; bool force_update = false; bool update_had_changes; serial_number_t previous_serial; serial_number_t current_serial; if (argc < 1 || argc > 2) { fprintf(stderr, "Usage: %s [<next serial number>]\n", argv[0]); fprintf(stderr, "\n"); fprintf(stderr, "The next serial number should only be specified in test mode.\n"); return EXIT_FAILURE; } OPEN_LOG("rtr-update", LOG_USER); if (!my_config_load()) { LOG(LOG_ERR, "can't load configuration"); return EXIT_FAILURE; } // initialize the database connection if (!db_init()) { LOG(LOG_ERR, "Could not initialize database program."); ret = EXIT_FAILURE; goto done; } done_db_init = true; if (!db_thread_init()) { LOG(LOG_ERR, "Could not initialize database thread."); ret = EXIT_FAILURE; goto done; } done_db_thread_init = true; db = db_connect_default(DB_CLIENT_RTR); if (db == NULL) { LOG(LOG_ERR, "Could not connect to the database, check your config " "file."); ret = EXIT_FAILURE; goto done; } if (!db_rtr_has_valid_session(db)) { return EXIT_FAILURE; } // Get the previous serial number. switch (db_rtr_get_latest_sernum(db, &previous_serial)) { case GET_SERNUM_SUCCESS: first_time = false; // previous_serial was set by db_rtr_get_latest_sernum break; case GET_SERNUM_NONE: first_time = true; // Set previous_serial to a pseudo-random number srandom((unsigned int)time(NULL)); previous_serial = (serial_number_t)random(); break; case GET_SERNUM_ERR: default: LOG(LOG_ERR, "Error finding latest serial number."); ret = EXIT_FAILURE; goto done; } if (!db_rtr_delete_incomplete_updates(db)) { LOG(LOG_ERR, "Error deleting incomplete updates."); ret = EXIT_FAILURE; goto done; } // Get/compute the current serial number. if (argc > 1) { force_update = true; if (sscanf(argv[1], "%" SCNSERIAL, ¤t_serial) != 1) { fprintf(stderr, "Error: next serial number must be a nonnegative integer\n"); return EXIT_FAILURE; } } else { // NOTE: this relies on unsigned integer wrap-around to zero current_serial = previous_serial + 1; } // Make sure we're not about to overwrite current_serial, create a // loop, or start a diverging history, even though these should be // *really* unlikely. if (!first_time && !db_rtr_good_serials(db, previous_serial, current_serial)) { if (argc > 1) { LOG(LOG_ERR, "Error: rtr_update is full or in an unusual state, " "or the specified next serial number already " "exists."); } else { LOG(LOG_ERR, "Error: rtr_update table is either full or in an " "unusual state."); } ret = EXIT_FAILURE; goto done; } if (!db_rtr_insert_full(db, current_serial)) { LOG(LOG_ERR, "Could not copy current RPKI state."); ret = EXIT_FAILURE; goto done; } if (!first_time && !db_rtr_insert_incremental(db, previous_serial, current_serial)) { LOG(LOG_ERR, "Could not compute incremental changes."); ret = EXIT_FAILURE; goto done; } if (first_time) { update_had_changes = true; } else { switch (db_rtr_has_incremental_changes(db, current_serial)) { case 1: update_had_changes = true; break; case 0: update_had_changes = false; break; case -1: default: LOG(LOG_ERR, "Error determining if there were any changes."); ret = EXIT_FAILURE; goto done; } } if (update_had_changes || force_update) { // Make the new serial number available for use. if ( !db_rtr_insert_update(db, current_serial, previous_serial, first_time)) { LOG(LOG_ERR, "Error making updates available."); ret = EXIT_FAILURE; goto done; } } else { LOG(LOG_INFO, "Data had no changes since the last update, so no update " "was made."); // The new data in rtr_full is useless, so delete it. if (!db_rtr_delete_full(db, current_serial)) { LOG(LOG_ERR, "Error deleting duplicate data in rtr_full."); ret = EXIT_FAILURE; goto done; } // there's nothing to delete from rtr_incremental } // clean up all the data no longer needed // save last two full updates so that no problems at transition // (with client still receiving data from previous one) // // NOTE: The order of these updates and deletes is important. // All data must be marked as unusable according to rtr_update // before it is deleted from rtr_full or rtr_incremental. if ( !db_rtr_ignore_old_full( db, current_serial, previous_serial) || !db_rtr_delete_old_full( db, current_serial, previous_serial) || !db_rtr_delete_old_update( db, current_serial, previous_serial) || !db_rtr_ignore_old_incremental(db) || !db_rtr_delete_old_incremental(db) || false) { LOG(LOG_ERR, "Error cleaning up old data."); ret = EXIT_FAILURE; goto done; } done: if (db != NULL) { db_disconnect(db); } if (done_db_thread_init) { db_thread_close(); } if (done_db_init) { db_close(); } config_unload(); CLOSE_LOG(); return ret; }
// initialize and parse the command line parameters bool Initialize(size_t argc, LPCTSTR* argv) { // initialize log and console OPEN_LOG(); OPEN_LOGCONSOLE(); // group of options allowed only on command line boost::program_options::options_description generic("Generic options"); generic.add_options() ("help,h", "produce this help message") ("working-folder,w", boost::program_options::value<std::string>(&WORKING_FOLDER), "working directory (default current directory)") ("config-file,c", boost::program_options::value<std::string>(&OPT::strConfigFileName)->default_value(APPNAME _T(".cfg")), "file name containing program options") ("archive-type", boost::program_options::value<unsigned>(&OPT::nArchiveType)->default_value(2), "project archive type: 0-text, 1-binary, 2-compressed binary") ("process-priority", boost::program_options::value<int>(&OPT::nProcessPriority)->default_value(-1), "process priority (below normal by default)") ("max-threads", boost::program_options::value<unsigned>(&OPT::nMaxThreads)->default_value(0), "maximum number of threads (0 for using all available cores)") #if TD_VERBOSE != TD_VERBOSE_OFF ("verbosity,v", boost::program_options::value<int>(&g_nVerbosityLevel)->default_value( #if TD_VERBOSE == TD_VERBOSE_DEBUG 3 #else 2 #endif ), "verbosity level") #endif ; // group of options allowed both on command line and in config file boost::program_options::options_description config("Main options"); config.add_options() ("input-file,i", boost::program_options::value<std::string>(&OPT::strInputFileName), "input filename containing camera poses and image list") ("output-file,o", boost::program_options::value<std::string>(&OPT::strOutputFileName), "output filename for storing the mesh") ("output-image-folder", boost::program_options::value<std::string>(&OPT::strOutputImageFolder)->default_value("undistorted_images"), "output folder to store undistorted images") ; boost::program_options::options_description cmdline_options; cmdline_options.add(generic).add(config); boost::program_options::options_description config_file_options; config_file_options.add(config); boost::program_options::positional_options_description p; p.add("input-file", -1); try { // parse command line options boost::program_options::store(boost::program_options::command_line_parser((int)argc, argv).options(cmdline_options).positional(p).run(), OPT::vm); boost::program_options::notify(OPT::vm); INIT_WORKING_FOLDER; // parse configuration file std::ifstream ifs(MAKE_PATH_SAFE(OPT::strConfigFileName)); if (ifs) { boost::program_options::store(parse_config_file(ifs, config_file_options), OPT::vm); boost::program_options::notify(OPT::vm); } } catch (const std::exception& e) { LOG(e.what()); return false; } // initialize the log file OPEN_LOGFILE(MAKE_PATH(APPNAME _T("-")+Util::getUniqueName(0)+_T(".log")).c_str()); // print application details: version and command line Util::LogBuild(); LOG(_T("Command line:%s"), Util::CommandLineToString(argc, argv).c_str()); // validate input Util::ensureValidPath(OPT::strInputFileName); Util::ensureUnifySlash(OPT::strInputFileName); if (OPT::vm.count("help") || OPT::strInputFileName.IsEmpty()) { boost::program_options::options_description visible("Available options"); visible.add(generic).add(config); GET_LOG() << visible; } if (OPT::strInputFileName.IsEmpty()) return false; // initialize optional options if (OPT::strInputFileName.IsEmpty()) return false; Util::ensureValidPath(OPT::strOutputFileName); Util::ensureUnifySlash(OPT::strOutputFileName); Util::ensureUnifySlash(OPT::strOutputImageFolder); Util::ensureDirectorySlash(OPT::strOutputImageFolder); if (OPT::strOutputFileName.IsEmpty()) OPT::strOutputFileName = Util::getFullFileName(OPT::strInputFileName) + MVS_EXT; // initialize global options Process::setCurrentProcessPriority((Process::Priority)OPT::nProcessPriority); #ifdef _USE_OPENMP if (OPT::nMaxThreads != 0) omp_set_num_threads(OPT::nMaxThreads); #endif #ifdef _USE_BREAKPAD // start memory dumper MiniDumper::Create(APPNAME, WORKING_FOLDER); #endif return true; }
int main( int argc, char **argv) { char **skis; char inbuf[128]; int numskis = 0; if (argc < 2) fatal("Usage: name of constraints file"); FILE *str = fopen(argv[1], "r"); if (!str) fatal("Can't open %s", argv[1]); FILE *tmpstr; char *f = "xproof.tmp"; int i = 0; struct keyring keyring = { NULL, NULL, NULL }; OPEN_LOG("proofreader", LOG_USER); if (!my_config_load()) { LOG(LOG_ERR, "can't load configuration"); exit(EXIT_FAILURE); } if (!(tmpstr = fopen(f, "w+"))) fatal("Can't open %s", f); if (parse_SKI_blocks(&keyring, str, argv[1], inbuf, sizeof(inbuf), &i) < 0) fatal("Invalid line: %s", errbuf); fseek(str, (long)0, 0); *inbuf = 0; while (1) { if (!fgets(inbuf, sizeof(inbuf), str)) abort(); if (!strncmp(inbuf, "SKI ", 4)) break; fputs(inbuf, tmpstr); } char *c; do // starting with first SKI line { for (c = &inbuf[4]; *c && ((*c >= '0' && *c <= '9') || *c == ':' || (*c >= 'A' && *c <= 'F') || (*c >= 'a' && *c <= 'f')); c++); if (c != &inbuf[63]) fatal("Invalid line: %s", inbuf); while (*c == ' ' || *c == '\t') c++; if (*c != '\n') fatal("Invalid line: %s", inbuf); if (numskis) { int num; for (num = 0; num < numskis && strcmp(inbuf, skis[num]); num++); if (num < numskis) fatal("Duplicate SKI: %s ", &inbuf[4]); } if (!numskis) skis = (char **)calloc(2, sizeof(char *)); else skis = (char **)realloc(skis, (sizeof(char *) * (numskis + 2))); skis[numskis] = calloc(1, strlen(inbuf) + 2); strcpy(skis[numskis], inbuf); numskis++; fputs(inbuf, tmpstr); // get IPv4 start if (!fgets(inbuf, sizeof(inbuf), str)) fatal("Premature end of file"); if (strcmp(inbuf, "IPv4\n")) fatal("Missing IPv4 line"); fputs(inbuf, tmpstr); // print v4 hdr // get first v4 line, if any if (!fgets(inbuf, sizeof(inbuf), str)) fatal("Premature end of file"); // process v4 entries, if any process_type(str, tmpstr, 4, inbuf, "IPv6\n"); fputs(inbuf, tmpstr); // print v6 hdr // get first v6 line, if any if (!fgets(inbuf, sizeof(inbuf), str)) fatal("Premature end of file"); process_type(str, tmpstr, 6, inbuf, "AS#\n"); fputs(inbuf, tmpstr); // print as# hdr // get first AS#, if any if (!(c = fgets(inbuf, sizeof(inbuf), str))) break; process_type(str, tmpstr, 8, inbuf, "SKI "); } while (*inbuf); if (warnings == 0) { LOG(LOG_INFO, "Finished %s OK", argv[1]); } else { LOG(LOG_ERR, "Had %d warnings. New file NOT created", warnings); } config_unload(); CLOSE_LOG(); return 0; }
int main( int argc, char **argv) { scmcon *testconp = NULL; scmcon *realconp = NULL; scm *scmp = NULL; FILE *sfile = NULL; char *thedelfile = NULL; char *topdir = NULL; char *thefile = NULL; char *outfile = NULL; char *outfull = NULL; char *outdir = NULL; char *tmpdsn = NULL; char *ne; char *porto = NULL; char errmsg[1024]; char *skifile = NULL; int ians = 0; int do_create = 0; int do_delete = 0; int do_sockopts = 0; int do_fileopts = 0; int use_filelist = 0; int perpetual = 0; int really = 0; int trusted = 0; int force = 0; int allowex = 0; int sta = 0; int s; int c; (void)setbuf(stdout, NULL); if (argc <= 1) { usage(); return (1); } while ((c = getopt(argc, argv, "t:xyhad:f:F:lLwz:pm:c:s")) != EOF) { switch (c) { case 'a': allowex = 1; break; case 't': do_create++; topdir = optarg; break; case 'x': do_delete++; break; case 'y': force++; break; case 'D': trusted++; case 'd': thedelfile = optarg; break; case 'F': trusted++; case 'f': thefile = optarg; break; case 'L': trusted++; case 'l': use_filelist++; break; case 'w': do_sockopts++; break; case 'z': do_fileopts++; porto = optarg; break; case 'p': perpetual++; break; case 'c': skifile = optarg; break; case 'h': usage(); return (0); case 's': strict_profile_checks = 1; // global from myssl.c strict_profile_checks_cms = 1; // global from roa_validate.c break; default: (void)fprintf(stderr, "Invalid option '%c'\n", c); usage(); return (1); } } // if there is anything left in argv, or no operation specified, warn user if (optind < argc) { (void)printf("Extra arguments at the end of the command line.\n"); usage(); return (1); } if ((do_create + do_delete + do_sockopts + do_fileopts) == 0 && thefile == 0 && thedelfile == 0 && skifile == 0 && use_filelist == 0) { (void)printf("You need to specify at least one operation " "(e.g. -f file).\n"); usage(); return (1); } OPEN_LOG("rcli", LOG_USER); if (!my_config_load()) { LOG(LOG_ERR, "can't load configuration"); exit(EXIT_FAILURE); } if (force == 0) { if (do_delete > 0) { ians = yorn("Do you REALLY want to delete all database tables"); if (ians <= 0) { LOG(LOG_NOTICE, "Delete operation cancelled"); return (1); } really++; } if ((do_create > 0) && (really == 0)) { ians = yorn("Do you REALLY want to create all database tables"); if (ians <= 0) { LOG(LOG_NOTICE, "Create operation cancelled"); return (1); } really++; } } scmp = initscm(); if (scmp == NULL) { LOG(LOG_ERR, "Internal error: cannot initialize database schema"); return (-2); } /* * If a create or delete operation is being performed, then a test dsn * will be needed; create it now and defer the creation of the real dsn * until later. Otherwise, create the real dsn. * * A test dsn is needed for operations that operate on the overall * database state as opposed to the rpki tables, namely the create and * delete operations. */ if ((do_create + do_delete) > 0) { /* * Note that in the following line, we do not intend to edit * the database named "information_schema". We are simply * filling in the "database name" parameter with something * that is guaranteed to be valid for MySQL. */ tmpdsn = makedsnscm(scmp->dsnpref, "information_schema", CONFIG_DATABASE_USER_get(), CONFIG_DATABASE_PASSWORD_get()); if (tmpdsn == NULL) { membail(); return (-1); } testconp = connectscm(tmpdsn, errmsg, 1024); memset(tmpdsn, 0, strlen(tmpdsn)); free((void *)tmpdsn); if (testconp == NULL) { LOG(LOG_ERR, "Cannot connect to DSN: %s", errmsg); freescm(scmp); return (-1); } } else { realconp = connectscm(scmp->dsn, errmsg, 1024); if (realconp == NULL) { LOG(LOG_ERR, "Cannot connect to DSN %s: %s", scmp->dsn, errmsg); freescm(scmp); return (-1); } } /* * Process command line options in the following order: delete, create, * dofile, dodir, listener. */ if (do_delete > 0) sta = deleteop(testconp, scmp); if ((do_create > 0) && (sta == 0)) /* first phase of create */ sta = createop(testconp, scmp); /* * Don't need the test connection any more */ if (testconp != NULL) { disconnectscm(testconp); testconp = NULL; } /* * If there has been an error or if we're done because the database was * just deleted and not re-created, bail out. */ if (sta < 0 || (do_delete > 0 && do_create == 0)) { if (realconp != NULL) disconnectscm(realconp); freescm(scmp); if (tdir != NULL) free((void *)tdir); return (sta); } /* * If a connection to the real DSN has not been opened yet, open it now. */ if (realconp == NULL) { realconp = connectscm(scmp->dsn, errmsg, 1024); if (realconp == NULL) { LOG(LOG_ERR, "Cannot connect to DSN %s: %s", scmp->dsn, errmsg); freescm(scmp); if (tdir != NULL) free((void *)tdir); return (-1); } } /* * If a create operation was requested, complete it now. */ if ((do_create > 0) && (sta == 0)) sta = create2op(scmp, realconp, topdir); /* * If the top level repository directory is not set, then retrieve it from * the database. */ if ((tdir == NULL) && (sta == 0)) { tdir = retrieve_tdir(scmp, realconp, &sta); if (tdir == NULL) LOG(LOG_ERR, "Cannot retrieve top level repository info from DB"); } if (sta == 0) { LOG(LOG_INFO, "Top level repository directory is %s", tdir); tdirlen = strlen(tdir); } /* * Setup for actual SSL operations */ OpenSSL_add_all_algorithms(); ERR_load_crypto_strings(); LOG(LOG_NOTICE, "Rsync client session started"); if (thefile != NULL && sta == 0) { // Check that the file is in the repository, ask if not and force is // off sta = splitdf(NULL, NULL, thefile, &outdir, &outfile, &outfull); if (sta == 0) { if (strncmp(tdir, outdir, tdirlen) != 0 && force == 0) { ians = yorn("That file is not in the repository. Proceed anyway"); if (ians <= 0) sta = 1; } // if ( strstr(outdir, "TRUST") != NULL ) // trusted++; // if the user has declared it to be trusted // ask for verification unless force is set if (trusted > 0 && force == 0 && sta == 0) { ians = yorn("Really declare this file as trusted"); if (ians <= 0) sta = 1; } if (sta == 1) LOG(LOG_NOTICE, "File operation cancelled"); if (sta == 0) { LOG(LOG_INFO, "Attempting add: %s", outfile); setallowexpired(allowex); sta = add_object(scmp, realconp, outfile, outdir, outfull, trusted); if (sta < 0) { LOG(LOG_ERR, "Add failed: %s: error %s (%d)", thefile, err2string(sta), sta); if (sta == ERR_SCM_SQL) { ne = geterrorscm(realconp); if (ne != NULL && ne != 0) LOG(LOG_ERR, "\t%s", ne); } } else LOG(LOG_INFO, "Add succeeded: %s", outfile); } free((void *)outdir); free((void *)outfile); free((void *)outfull); } else LOG(LOG_ERR, "%s (%d)", err2string(sta), sta); } if (use_filelist > 0 && sta == 0) { char *line = NULL; size_t len = 0; ssize_t read; int status; setallowexpired(allowex); while ((read = getline(&line, &len, stdin)) != -1) { if (read == 0) continue; // Trim newline and skip line if empty if (line[read - 1] == '\n') line[read - 1] = '\0'; if (strlen(line) == 0) continue; // Split directory and file components of path status = splitdf(NULL, NULL, line, &outdir, &outfile, &outfull); if (status != 0) { LOG(LOG_ERR, "%s (%d)", err2string(status), status); continue; } LOG(LOG_INFO, "Attempting add: %s", outfile); // Warn if file not within repository directory if (strncmp(tdir, outdir, tdirlen) != 0) LOG(LOG_WARNING, "%s is not in the repository", line); // Add status = add_object(scmp, realconp, outfile, outdir, outfull, trusted); if (status == 0) { LOG(LOG_INFO, "Add succeeded: %s", outfile); } else { LOG(LOG_ERR, "Add failed: %s: error %s (%d)", line, err2string(status), status); if (status == ERR_SCM_SQL) { ne = geterrorscm(realconp); if (ne != NULL && ne != 0) LOG(LOG_ERR, "\t%s", ne); } } free((void *)outdir); free((void *)outfile); free((void *)outfull); } free(line); } if (thedelfile != NULL && sta == 0) { sta = splitdf(NULL, NULL, thedelfile, &outdir, &outfile, &outfull); if (sta == 0) { sta = delete_object(scmp, realconp, outfile, outdir, outfull, 0); if (sta < 0) { LOG(LOG_ERR, "Could not delete file %s: error %s (%d)", thedelfile, err2string(sta), sta); if (sta == ERR_SCM_SQL) { ne = geterrorscm(realconp); if (ne != NULL && ne != 0) LOG(LOG_ERR, "\t%s", ne); } } else LOG(LOG_INFO, "Delete operation succeeded (%s removed)", thedelfile); free((void *)outdir); free((void *)outfile); free((void *)outfull); } else LOG(LOG_ERR, "Error: %s (%d)", err2string(sta), sta); } if ((do_sockopts + do_fileopts) > 0 && sta == 0) { int protos = (-1); const int max_makesock_attempts = 10; int makesock_failures = 0; do { if (do_sockopts > 0) { uint16_t port = CONFIG_RPKI_PORT_get(); s = makesock(port, &protos); if (s < 0) { makesock_failures++; LOG(LOG_ERR, "Failed to listen on port %" PRIu16 " (failure #%d)", port, makesock_failures); sleep(1); if (makesock_failures >= max_makesock_attempts) { LOG(LOG_ERR, "%d failed attempts to create socket. Aborting.", max_makesock_attempts); sta = -1; break; } } else { makesock_failures = 0; FLUSH_LOG(); sta = sockline(scmp, realconp, s); LOG(LOG_INFO, "Socket connection closed"); FLUSH_LOG(); (void)close(s); } } if (do_fileopts > 0 && porto != NULL) { if (!isatty(0)) { LOG(LOG_DEBUG, "Opening stdin"); sfile = stdin; sta = fileline(scmp, realconp, sfile); } else { LOG(LOG_DEBUG, "Opening a socket cmdfile %s", porto); sfile = fopen(porto, "r"); if (sfile == NULL) LOG(LOG_ERR, "Could not open cmdfile"); else { sta = fileline(scmp, realconp, sfile); LOG(LOG_DEBUG, "Cmdfile closed"); (void)fclose(sfile); } } } if (sta == 0 && skifile) { LOG(LOG_DEBUG, "Starting skifile %s", skifile); sta = read_SKI_blocks(scmp, realconp, skifile); if (sta > 0) sta = 0; if (sta) LOG(LOG_ERR, "Error with skifile: %s (%d)", err2string(sta), sta); } } while (perpetual > 0); if (protos >= 0) (void)close(protos); } if (sta == 0 && skifile) { LOG(LOG_DEBUG, "Starting skifile %s", skifile); sta = read_SKI_blocks(scmp, realconp, skifile); if (sta > 0) sta = 0; if (sta) LOG(LOG_ERR, "Error with skifile: %s (%d)", err2string(sta), sta); } (void)ranlast(scmp, realconp, "RSYNC"); sqcleanup(); if (realconp != NULL) disconnectscm(realconp); freescm(scmp); if (tdir != NULL) free((void *)tdir); LOG(LOG_NOTICE, "Rsync client session ended"); config_unload(); CLOSE_LOG(); return (sta); }
int main( int argc, char **argv) { /* * Args are: file TBS, keyfile, [update] */ struct Certificate cert; Certificate(&cert, (ushort) 0); struct CertificateRevocationList crl; CertificateRevocationList(&crl, (ushort) 0); struct Blob blob; Blob(&blob, (ushort) 0); struct AlgorithmIdentifier *algp, *tbsalgp; struct casn *casnp, *sigp, *selfp; const char *keyfile = NULL; OPEN_LOG("sign_cert", LOG_USER); if (argc < 3) FATAL(MSG_USAGE); char *sfx = strrchr(argv[1], (int)'.'); keyfile = argv[2]; if (!strcmp(sfx, ".cer")) { selfp = &cert.self; casnp = &cert.toBeSigned.self; tbsalgp = &cert.toBeSigned.signature; sigp = &cert.signature; algp = &cert.algorithm; } else if (!strcmp(sfx, ".crl")) { selfp = &crl.self; casnp = &crl.toBeSigned.self; tbsalgp = &crl.toBeSigned.signature; sigp = &crl.signature; algp = &crl.algorithm; } else if (!strcmp(sfx, ".blb")) { selfp = &blob.self; casnp = &blob.toBeSigned; tbsalgp = NULL; sigp = &blob.signature; algp = &blob.algorithm; } else { FATAL(MSG_UNK_EXT, argv[1]); } if (get_casn_file(selfp, argv[1], 0) < 0) FATAL(MSG_OPEN, argv[1]); if (argv[3] && (*argv[3] & 1)) { if (!strcmp(sfx, ".cer")) adjust_time(&cert.toBeSigned.validity.notBefore.utcTime, &cert.toBeSigned.validity.notAfter.utcTime); else if (!strcmp(sfx, ".crl")) adjust_time((struct casn *)&crl.toBeSigned.lastUpdate, (struct casn *)&crl.toBeSigned.nextUpdate); } if (tbsalgp && (!argv[3] || !(*argv[3] & 2))) { write_objid(&tbsalgp->algorithm, id_sha_256WithRSAEncryption); write_casn(&tbsalgp->parameters.rsadsi_SHA256_WithRSAEncryption, (uchar *) "", 0); } if (!set_signature(casnp, sigp, keyfile, "label", "password", false)) { FATAL(MSG_IN, "set_signature()"); } if (!argv[3] || !(*argv[3] & 4)) { write_objid(&algp->algorithm, id_sha_256WithRSAEncryption); write_casn(&algp->parameters.rsadsi_SHA256_WithRSAEncryption, (uchar *) "", 0); } put_casn_file(selfp, argv[1], 0); DONE(MSG_OK, argv[1]); return 0; }
int main(int argc, char *argv[]) #endif { fd_set rfds; struct timeval tv; int server_socket = -1; int bytes, retval; struct dhcpMessage packet; unsigned char *state; unsigned char *server_id, *requested, *hostname; u_int32_t server_id_align, requested_align; unsigned long timeout_end; struct option_set *option; struct dhcpOfferedAddr *lease; int pid_fd; int max_sock; int sig; /* DD-WRT (belanger) : ignore signals until we're ready */ signal(SIGUSR1, SIG_IGN); signal(SIGUSR2, SIG_IGN); signal(SIGHUP, SIG_IGN); signal(SIGTERM, SIG_IGN); OPEN_LOG("udhcpd"); LOG(LOG_INFO, "udhcp server (v%s) started", VERSION); memset(&server_config, 0, sizeof(struct server_config_t)); if (argc < 2) read_config(DHCPD_CONF_FILE); else read_config(argv[1]); pid_fd = pidfile_acquire(server_config.pidfile); pidfile_write_release(pid_fd); if ((option = find_option(server_config.options, DHCP_LEASE_TIME))) { memcpy(&server_config.lease, option->data + 2, 4); server_config.lease = ntohl(server_config.lease); } else server_config.lease = LEASE_TIME; leases = malloc(sizeof(struct dhcpOfferedAddr) * server_config.max_leases); memset(leases, 0, sizeof(struct dhcpOfferedAddr) * server_config.max_leases); read_leases(server_config.lease_file); read_statics(server_config.statics_file); /* DD-WRT (belanger) : write leases now */ write_leases(); if (read_interface(server_config.interface, &server_config.ifindex, &server_config.server, server_config.arp) < 0) exit_server(1); #ifndef DEBUGGING pid_fd = pidfile_acquire(server_config.pidfile); /* hold lock during fork. */ if (daemon(0, 0) == -1) { perror("fork"); exit_server(1); } pidfile_write_release(pid_fd); #endif socketpair(AF_UNIX, SOCK_STREAM, 0, signal_pipe); signal(SIGUSR1, signal_handler); signal(SIGUSR2, signal_handler); signal(SIGTERM, signal_handler); signal(SIGHUP, signal_handler); timeout_end = get_time(0) + server_config.auto_time; while(1) { /* loop until universe collapses */ if (server_socket < 0) if ((server_socket = listen_socket(INADDR_ANY, SERVER_PORT, server_config.interface)) < 0) { LOG(LOG_ERR, "FATAL: couldn't create server socket, %s", strerror(errno)); exit_server(0); } FD_ZERO(&rfds); FD_SET(server_socket, &rfds); FD_SET(signal_pipe[0], &rfds); if (server_config.auto_time) { tv.tv_sec = timeout_end - get_time(0); tv.tv_usec = 0; } if (!server_config.auto_time || tv.tv_sec > 0) { max_sock = server_socket > signal_pipe[0] ? server_socket : signal_pipe[0]; retval = select(max_sock + 1, &rfds, NULL, NULL, server_config.auto_time ? &tv : NULL); } else retval = 0; /* If we already timed out, fall through */ if (retval == 0) { write_leases(); timeout_end = get_time(0) + server_config.auto_time; continue; } else if (retval < 0 && errno != EINTR) { DEBUG(LOG_INFO, "error on select"); continue; } if (FD_ISSET(signal_pipe[0], &rfds)) { if (read(signal_pipe[0], &sig, sizeof(sig)) < 0) continue; /* probably just EINTR */ switch (sig) { case SIGUSR1: LOG(LOG_INFO, "Received a SIGUSR1"); write_leases(); /* why not just reset the timeout, eh */ timeout_end = get_time(0) + server_config.auto_time; continue; case SIGUSR2: LOG(LOG_INFO, "Received a SIGUSR2"); delete_leases(); continue; case SIGHUP: LOG(LOG_INFO, "Received a SIGHUP"); read_leases(server_config.lease_file); read_statics(server_config.statics_file); continue; case SIGTERM: LOG(LOG_INFO, "Received a SIGTERM"); exit_server(0); } } if ((bytes = get_packet(&packet, server_socket)) < 0) { /* this waits for a packet - idle */ if (bytes == -1 && errno != EINTR) { DEBUG(LOG_INFO, "error on read, %s, reopening socket", strerror(errno)); close(server_socket); server_socket = -1; } continue; } if ((state = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) { DEBUG(LOG_ERR, "couldn't get option from packet, ignoring"); continue; } hostname = get_option(&packet, DHCP_HOST_NAME); /* ADDME: look for a static lease */ /* If a hostname is supplied, and that hostname is a static lease, and that static lease has an FF:FF:FF:FF:FF:FF MAC address, then use that entry. */ if ( NULL == hostname || NULL == (lease = find_lease_by_hostname(hostname)) || (lease->expires != EXPIRES_NEVER) || 0 != memcmp(lease->chaddr, MAC_BCAST_ADDR, strlen(MAC_BCAST_ADDR))) { /* Otherwise, look up the table using the supplied MAC address. */ lease = find_lease_by_chaddr(packet.chaddr); } switch (state[0]) { case DHCPDISCOVER: LOG(LOG_INFO,"received DISCOVER from %02x:%02x:%02x:%02x:%02x:%02x", packet.chaddr[0], packet.chaddr[1], packet.chaddr[2], packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]); // modify by honor if (sendOffer(&packet, lease) < 0) { LOG(LOG_ERR, "send OFFER failed"); } break; case DHCPREQUEST: requested = get_option(&packet, DHCP_REQUESTED_IP); server_id = get_option(&packet, DHCP_SERVER_ID); if (requested) memcpy(&requested_align, requested, 4); if (server_id) memcpy(&server_id_align, server_id, 4); if (requested) { struct in_addr addr; addr.s_addr = requested_align; LOG(LOG_INFO, "received REQUEST for %s from %02x:%02x:%02x:%02x:%02x:%02x", inet_ntoa(addr), packet.chaddr[0], packet.chaddr[1], packet.chaddr[2], packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]); } else { LOG(LOG_INFO, "received REQUEST from %02x:%02x:%02x:%02x:%02x:%02x", packet.chaddr[0], packet.chaddr[1], packet.chaddr[2], packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]); } if (lease) { /*ADDME: or static lease */ if (server_id) { /* SELECTING State */ DEBUG(LOG_INFO, "server_id = %08x", ntohl(server_id_align)); if (server_id_align == server_config.server && requested && requested_align == lease->yiaddr) { sendACK(&packet, lease->yiaddr); } else sendNAK(&packet); //Sveasoft - shouldn't we let them know we don't like the request? } else { if (requested) { /* INIT-REBOOT State */ if (lease->yiaddr == requested_align) sendACK(&packet, lease->yiaddr); else sendNAK(&packet); } else { /* RENEWING or REBINDING State */ if (lease->yiaddr == packet.ciaddr) sendACK(&packet, lease->yiaddr); // else if (!packet.ciaddr) /* Accept an invalid request in RENEWING state, where the ciaddr should be set, but is not. */ /* e.g. Linksys Print Server */ // sendACK(&packet, lease->yiaddr); //note: let's not support broken stuff - Sveasoft 2005-01-19 else { /* don't know what to do!!!! */ sendNAK(&packet); } } } if (lease->expires != EXPIRES_NEVER) { /* Don't change hostname of static leases */ if (hostname) { bytes = hostname[-1]; if (bytes >= (int) sizeof(lease->hostname)) bytes = sizeof(lease->hostname) - 1; strncpy(lease->hostname, hostname, bytes); lease->hostname[bytes] = '\0'; } else lease->hostname[0] = '\0'; } /* what to do if we have no record of the client */ } else if (server_id) { /* SELECTING State */ sendNAK(&packet); // by honor } else if (requested) { /* INIT-REBOOT State */ if ((lease = find_lease_by_yiaddr(requested_align))) { if (lease_expired(lease)) { /* probably best if we drop this lease */ memset(lease->chaddr, 0, 16); /* make some contention for this address */ } else sendNAK(&packet); } else if (requested_align < server_config.start || requested_align > server_config.end) { sendNAK(&packet); } else { sendNAK(&packet); } } else if (packet.ciaddr) { /* RENEWING or REBINDING State */ sendNAK(&packet); } break; case DHCPDECLINE: LOG(LOG_INFO,"received DECLINE from %02x:%02x:%02x:%02x:%02x:%02x", packet.chaddr[0], packet.chaddr[1], packet.chaddr[2], packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]); // modify by honor if (lease && lease->expires != EXPIRES_NEVER) { memset(lease->chaddr, 0, 16); lease->expires = get_time(0) + server_config.decline_time; } break; case DHCPRELEASE: LOG(LOG_INFO,"received RELEASE from %02x:%02x:%02x:%02x:%02x:%02x", packet.chaddr[0], packet.chaddr[1], packet.chaddr[2], packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]); // modify by honor if (lease && lease->expires != EXPIRES_NEVER) lease->expires = get_time(0); break; case DHCPINFORM: LOG(LOG_INFO,"received INFORM from %02x:%02x:%02x:%02x:%02x:%02x", packet.chaddr[0], packet.chaddr[1], packet.chaddr[2], packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]); // modify by honor send_inform(&packet); break; default: LOG(LOG_WARNING, "unsupported DHCP message (%02x) -- ignoring", state[0]); } } return 0; }
int main( int argc, char **argv) { char *displays[MAX_VALS]; char *clauses[MAX_CONDS]; char *orderp = NULL; int i; err_code status; int numDisplays = 0; int numClauses = 0; OPEN_LOG("query", LOG_USER); if (!my_config_load()) { LOG(LOG_ERR, "can't initialize configuration"); exit(EXIT_FAILURE); } output = stdout; useLabels = 1; multiline = 0; validate = 1; if (argc == 1) return printUsage(); if (strcasecmp(argv[1], "-l") == 0) { if (argc != 3) return printUsage(); setObjectType(argv[2]); return listOptions(); } for (i = 1; i < argc; i += 2) { if (strcasecmp(argv[i], "-i") == 0) { validate = 0; i--; } else if (strcasecmp(argv[i], "-n") == 0) { useLabels = 0; i--; } else if (strcasecmp(argv[i], "-m") == 0) { multiline = 1; i--; } else if (argc == (i + 1)) { return printUsage(); } else if (strcasecmp(argv[i], "-t") == 0) { setObjectType(argv[i + 1]); } else if (strcasecmp(argv[i], "-d") == 0) { displays[numDisplays++] = argv[i + 1]; } else if (strcasecmp(argv[i], "-f") == 0) { clauses[numClauses++] = argv[i + 1]; } else if (strcasecmp(argv[i], "-o") == 0) { output = fopen(argv[i + 1], "w"); } else if (strcasecmp(argv[i], "-x") == 0) { orderp = argv[i + 1]; } else { // unknown switch return printUsage(); } } checkErr((!isROA) && (!isCRL) && (!isCert) && (!isManifest) && (!isGBR), BAD_OBJECT_TYPE); checkErr(numDisplays == 0, "Need to display something\n"); if (numDisplays == 1 && strcasecmp(displays[0], "all") == 0) numDisplays = addAllFields(displays, 0); displays[numDisplays++] = NULL; clauses[numClauses++] = NULL; status = doQuery(displays, clauses, orderp); if (status == ERR_SCM_NODATA) { LOG(LOG_DEBUG, "%s", err2string(status)); status = 0; } else if (status < 0) { LOG(LOG_ERR, "%s", err2string(status)); } config_unload(); CLOSE_LOG(); return status; }
int coveragescanner(int argc,char **argv) { #ifdef __COVERAGESCANNER__ __coveragescanner_install(argv[0]); #endif #if LOG signal(SIGABRT,sighandler); signal(SIGTERM,sighandler); signal(SIGFPE,sighandler); signal(SIGILL,sighandler); signal(SIGINT,sighandler); signal(SIGSEGV,sighandler); signal(SIGTERM,sighandler); #endif #ifdef SEFLTEST setenv("EF_PROTECT_FREE","1",0); setenv("EF_FREE_WIPE","1",0); #endif #if 0 if (strcmp(argv[0],"link.exe")==0) DebugBreak(); #endif #if LOG OPEN_LOG(); DEBUG5("TestCocoon v%i.%i.%i date:%s\n",(TESTCOCOON_VERSION>>16),(TESTCOCOON_VERSION>>8)&0xFF, TESTCOCOON_VERSION&0xFF ,__DATE__); std::string cmd; for (int i=0;i<argc;i++) { cmd+=" "; cmd+=System::quoteArgument(argv[i]); } DEBUG2("cmd=%s\n",cmd.c_str()); for (int ilog=0;ilog<argc;ilog++) { DEBUG3("Argv[%i]=%s\n",ilog,argv[ilog]); } #endif bool coveragescanner_disable_env=CompilerInterface::isCoverageScannerDisabledPerEnvironmentVariable(); if (coveragescanner_disable_env) { DEBUG1("COVERAGESCANNER_DISABLE is set\n"); } Option option(argc,argv); CompilerInterface::disableCoverageScannerPerEnvironmentVariable(); if (coveragescanner_disable_env || option.isInactive()) { DEBUG1("Do not instrument source file, call the native tool.\n"); DEBUG3("call_native_tool(%s,%s)\n",option.profileToolName().c_str(),option.param_args()[0]); CompilerInterface *compiler_p=CompilerFactory::create(option); if (compiler_p==NULL) { FATAL1("Could not find CoverageScanner profile!"); } int ret = compiler_p->callNativeTool(); TmpFile::object().deleteFiles(); return ret; } //DebugBreak(); #if defined(LOG) || !defined(NO_DEBUG) fprintf(stderr,"CoverageScanner (\"%s\") is build in debug mode.\n",argv[0]); #endif DEBUG1("Instrument source file, not calling the native tool.\n"); Compiler compiler(option); if (!compiler.generate()) { FATAL2("Error:%s\n",compiler.error()); } MEMORY_REPORT; return (0); }
int main(int argc, char *argv[]){ struct file_records_t file_records; int sourcefd = -1; if ( argc > 2 ){ char logname[50]; sprintf(logname, "%s%s%s.log", CLIENT_LOG, SOURCE, argv[2]); OPEN_LOG(logname, SOURCE, atoi(argv[2])); file_records.vfs_path = argv[1]; int err = get_all_files_from_dbtable(DB_PATH, SOURCE, &file_records); WRITE_FMT_LOG(LOG_ERR, "get_all_files_from_dbtable err=%d", err); if ( err != 0 ) return 1; } else{ printf("usage: 1st arg: should be path to VFS folder, 2nd: unique node integer id\n");fflush(0); return 1; } int nodeid = atoi(argv[2]); BigArrayPtr unsorted_array = NULL; BigArrayPtr partially_sorted_array = NULL; /*get unsorted data*/ char inputfile[100]; memset(inputfile, '\0', 100); sprintf(inputfile, SOURCE_FILE_FMT, nodeid ); sourcefd = open(inputfile, O_RDONLY); if ( sourcefd >= 0 ){ const size_t data_size = sizeof(BigArrayItem)*ARRAY_ITEMS_COUNT; unsorted_array = malloc( data_size ); if ( unsorted_array ){ const ssize_t readed = read(sourcefd, unsorted_array, data_size); assert(readed == data_size ); } close(sourcefd); } else{ WRITE_FMT_LOG(LOG_ERR, "Can not open input file %s", inputfile); exit(0); } /*sort data locally*/ partially_sorted_array = alloc_merge_sort( unsorted_array, ARRAY_ITEMS_COUNT ); //if first part of sorting in single thread are completed if ( test_sort_result( unsorted_array, partially_sorted_array, ARRAY_ITEMS_COUNT ) ){ if ( ARRAY_ITEMS_COUNT ){ WRITE_FMT_LOG(LOG_UI, "Single process sorting complete min=%u, max=%u: TEST OK.\n", partially_sorted_array[0], partially_sorted_array[ARRAY_ITEMS_COUNT-1] ); } /*send crc of sorted array to the manager node*/ uint32_t crc = array_crc( partially_sorted_array, ARRAY_ITEMS_COUNT ); WRITE_FMT_LOG(LOG_DEBUG, "crc=%u", crc); struct file_record_t* write_crc_r = match_file_record_by_fd( &file_records, SOURCE_FD_WRITE_CRC); WRITE_FMT_LOG(LOG_DEBUG, "SOURCE_FD_WRITE_CRC fd=%p", write_crc_r); assert(write_crc_r); write_crc( write_crc_r->fpath, crc ); WRITE_LOG(LOG_DEBUG, "crc wrote"); /*send of crc complete*/ int histogram_len = 0; HistogramArrayPtr histogram_array = alloc_histogram_array_get_len( partially_sorted_array, 0, ARRAY_ITEMS_COUNT, 1000, &histogram_len ); struct Histogram single_histogram; single_histogram.src_nodeid = nodeid; single_histogram.array_len = histogram_len; single_histogram.array = histogram_array; //send histogram to manager struct file_record_t* write_hist_r = match_file_record_by_fd( &file_records, SOURCE_FD_WRITE_HISTOGRAM); assert(write_hist_r); write_histogram( write_hist_r->fpath, &single_histogram ); struct file_record_t* read_dhist_req_r = match_file_record_by_fd( &file_records, SOURCE_FD_READ_D_HISTOGRAM_REQ); struct file_record_t* write_dhist_req_r = match_file_record_by_fd( &file_records, SOURCE_FD_WRITE_D_HISTOGRAM_REQ); assert(read_dhist_req_r); assert(write_dhist_req_r); read_requests_write_detailed_histograms( read_dhist_req_r->fpath, write_dhist_req_r->fpath, nodeid, partially_sorted_array, ARRAY_ITEMS_COUNT ); WRITE_LOG(LOG_DETAILED_UI, "\n!!!!!!!Histograms Sending complete!!!!!!.\n"); struct request_data_t req_data_array[SRC_NODES_COUNT]; init_request_data_array( req_data_array, SRC_NODES_COUNT); ////////////////////////////// struct file_record_t* read_sequnce_req_r = match_file_record_by_fd( &file_records, SOURCE_FD_READ_SEQUENCES_REQ); assert(read_sequnce_req_r); read_range_request( read_sequnce_req_r->fpath, req_data_array ); ////////////////////////////// ////////////////////////////// for ( int i=0; i < SRC_NODES_COUNT; i++ ){ int dst_nodeid = req_data_array[i].dst_nodeid; int dst_write_fd = dst_nodeid - FIRST_DEST_NODEID + SOURCE_FD_WRITE_SORTED_RANGES_REQ; int dst_read_fd = dst_nodeid - FIRST_DEST_NODEID + SOURCE_FD_READ_SORTED_RANGES_REQ; WRITE_FMT_LOG(LOG_DEBUG, "write_sorted_ranges fdw=%d, fdr=%d", dst_write_fd, dst_read_fd ); struct file_record_t* write_ranges_req_r = match_file_record_by_fd( &file_records, dst_write_fd); struct file_record_t* read_ranges_req_r = match_file_record_by_fd( &file_records, dst_read_fd); assert(write_ranges_req_r); assert(read_ranges_req_r); WRITE_FMT_LOG(LOG_DEBUG, "req_data_array[i].dst_nodeid=%d", req_data_array[i].dst_nodeid ); write_sorted_ranges( write_ranges_req_r->fpath, read_ranges_req_r->fpath, &req_data_array[i], partially_sorted_array ); } WRITE_FMT_LOG(LOG_DETAILED_UI, "[%d]Sending Ranges Complete-OK", nodeid); ////////////////////////////// free(unsorted_array); free(partially_sorted_array); } else{ WRITE_LOG(LOG_UI, "Single process sorting failed: TEST FAILED.\n"); exit(0); } }
int main(int argc, char *argv[]) #endif { unsigned char *temp, *message; unsigned long t1 = 0, t2 = 0, xid = 0; unsigned long start = 0, lease; fd_set rfds; int retval; struct timeval tv; int c, len; struct dhcpMessage packet; struct in_addr temp_addr; int pid_fd; time_t now; int max_fd; int sig; static struct option arg_options[] = { {"clientid", required_argument, 0, 'c'}, {"foreground", no_argument, 0, 'f'}, {"background", no_argument, 0, 'b'}, {"hostname", required_argument, 0, 'H'}, {"hostname", required_argument, 0, 'h'}, {"interface", required_argument, 0, 'i'}, {"now", no_argument, 0, 'n'}, {"pidfile", required_argument, 0, 'p'}, {"quit", no_argument, 0, 'q'}, {"request", required_argument, 0, 'r'}, {"script", required_argument, 0, 's'}, {"version", no_argument, 0, 'v'}, {"help", no_argument, 0, '?'}, {0, 0, 0, 0} }; /* get options */ while (1) { int option_index = 0; c = getopt_long(argc, argv, "c:fbH:h:i:np:qr:s:v", arg_options, &option_index); if (c == -1) break; switch (c) { case 'c': len = strlen(optarg) > 255 ? 255 : strlen(optarg); if (client_config.clientid) free(client_config.clientid); client_config.clientid = xmalloc(len + 2); client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID; client_config.clientid[OPT_LEN] = len; client_config.clientid[OPT_DATA] = '\0'; strncpy(client_config.clientid + OPT_DATA, optarg, len); break; case 'f': client_config.foreground = 1; break; case 'b': client_config.background_if_no_lease = 1; break; case 'h': case 'H': len = strlen(optarg) > 255 ? 255 : strlen(optarg); if (client_config.hostname) free(client_config.hostname); client_config.hostname = xmalloc(len + 2); client_config.hostname[OPT_CODE] = DHCP_HOST_NAME; client_config.hostname[OPT_LEN] = len; strncpy(client_config.hostname + 2, optarg, len); break; case 'i': client_config.interface = optarg; break; case 'n': client_config.abort_if_no_lease = 1; break; case 'p': client_config.pidfile = optarg; break; case 'q': client_config.quit_after_lease = 1; break; case 'r': requested_ip = inet_addr(optarg); break; case 's': client_config.script = optarg; break; case 'v': printf("udhcpcd, version %s\n\n", VERSION); exit_client(0); break; default: show_usage(); } } OPEN_LOG("udhcpc"); LOG(LOG_INFO, "udhcp client (v%s) started", VERSION); pid_fd = pidfile_acquire(client_config.pidfile); pidfile_write_release(pid_fd); if (read_interface(client_config.interface, &client_config.ifindex, NULL, client_config.arp) < 0) exit_client(1); if (!client_config.clientid) { client_config.clientid = xmalloc(6 + 3); client_config.clientid[OPT_CODE] = DHCP_CLIENT_ID; client_config.clientid[OPT_LEN] = 7; client_config.clientid[OPT_DATA] = 1; memcpy(client_config.clientid + 3, client_config.arp, 6); } /* setup signal handlers */ socketpair(AF_UNIX, SOCK_STREAM, 0, signal_pipe); signal(SIGUSR1, signal_handler); signal(SIGUSR2, signal_handler); signal(SIGTERM, signal_handler); state = INIT_SELECTING; run_script(NULL, "deconfig"); change_mode(LISTEN_RAW); for (;;) { tv.tv_sec = timeout - time(0); tv.tv_usec = 0; FD_ZERO(&rfds); if (listen_mode != LISTEN_NONE && fd < 0) { if (listen_mode == LISTEN_KERNEL) fd = listen_socket(INADDR_ANY, CLIENT_PORT, client_config.interface); else fd = raw_socket(client_config.ifindex); if (fd < 0) { LOG(LOG_ERR, "FATAL: couldn't listen on socket, %s", strerror(errno)); exit_client(0); } } if (fd >= 0) FD_SET(fd, &rfds); FD_SET(signal_pipe[0], &rfds); if (tv.tv_sec > 0) { DEBUG(LOG_INFO, "Waiting on select...\n"); max_fd = signal_pipe[0] > fd ? signal_pipe[0] : fd; retval = select(max_fd + 1, &rfds, NULL, NULL, &tv); } else retval = 0; /* If we already timed out, fall through */ now = time(0); if (retval == 0) { /* timeout dropped to zero */ switch (state) { case INIT_SELECTING: if (packet_num < 3) { if (packet_num == 0) xid = random_xid(); /* send discover packet */ send_discover(xid, requested_ip); /* broadcast */ timeout = now + ((packet_num == 2) ? 4 : 2); packet_num++; } else { if (client_config.background_if_no_lease) { LOG(LOG_INFO, "No lease, forking to background."); background(); } else if (client_config.abort_if_no_lease) { LOG(LOG_INFO, "No lease, failing."); exit_client(1); } /* wait to try again */ packet_num = 0; timeout = now + 60; } break; case RENEW_REQUESTED: case REQUESTING: if (packet_num < 3) { /* send request packet */ if (state == RENEW_REQUESTED) send_renew(xid, server_addr, requested_ip); /* unicast */ else send_selecting(xid, server_addr, requested_ip); /* broadcast */ timeout = now + ((packet_num == 2) ? 10 : 2); packet_num++; } else { /* timed out, go back to init state */ if (state == RENEW_REQUESTED) run_script(NULL, "deconfig"); state = INIT_SELECTING; timeout = now; packet_num = 0; change_mode(LISTEN_RAW); } break; case BOUND: /* Lease is starting to run out, time to enter renewing state */ state = RENEWING; change_mode(LISTEN_KERNEL); DEBUG(LOG_INFO, "Entering renew state"); /* fall right through */ case RENEWING: /* Either set a new T1, or enter REBINDING state */ if ((t2 - t1) <= (lease / 14400 + 1)) { /* timed out, enter rebinding state */ state = REBINDING; timeout = now + (t2 - t1); DEBUG(LOG_INFO, "Entering rebinding state"); } else { /* send a request packet */ send_renew(xid, server_addr, requested_ip); /* unicast */ t1 = (t2 - t1) / 2 + t1; timeout = t1 + start; } break; case REBINDING: /* Either set a new T2, or enter INIT state */ if ((lease - t2) <= (lease / 14400 + 1)) { /* timed out, enter init state */ state = INIT_SELECTING; LOG(LOG_INFO, "Lease lost, entering init state"); run_script(NULL, "deconfig"); timeout = now; packet_num = 0; change_mode(LISTEN_RAW); } else { /* send a request packet */ send_renew(xid, 0, requested_ip); /* broadcast */ t2 = (lease - t2) / 2 + t2; timeout = t2 + start; } break; case RELEASED: /* yah, I know, *you* say it would never happen */ timeout = 0x7fffffff; break; } } else if (retval > 0 && listen_mode != LISTEN_NONE && FD_ISSET(fd, &rfds)) { /* a packet is ready, read it */ if (listen_mode == LISTEN_KERNEL) len = get_packet(&packet, fd); else len = get_raw_packet(&packet, fd); if (len == -1 && errno != EINTR) { DEBUG(LOG_INFO, "error on read, %s, reopening socket", strerror(errno)); change_mode(listen_mode); /* just close and reopen */ } if (len < 0) continue; if (packet.xid != xid) { DEBUG(LOG_INFO, "Ignoring XID %lx (our xid is %lx)", (unsigned long) packet.xid, xid); continue; } if ((message = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) { DEBUG(LOG_ERR, "couldnt get option from packet -- ignoring"); continue; } switch (state) { case INIT_SELECTING: /* Must be a DHCPOFFER to one of our xid's */ if (*message == DHCPOFFER) { if ((temp = get_option(&packet, DHCP_SERVER_ID))) { memcpy(&server_addr, temp, 4); xid = packet.xid; requested_ip = packet.yiaddr; /* enter requesting state */ state = REQUESTING; timeout = now; packet_num = 0; } else { DEBUG(LOG_ERR, "No server ID in message"); } } break; case RENEW_REQUESTED: case REQUESTING: case RENEWING: case REBINDING: if (*message == DHCPACK) { if (!(temp = get_option(&packet, DHCP_LEASE_TIME))) { LOG(LOG_ERR, "No lease time with ACK, using 1 hour lease"); lease = 60 * 60; } else { memcpy(&lease, temp, 4); lease = ntohl(lease); } /* enter bound state */ t1 = lease / 2; /* little fixed point for n * .875 */ t2 = (lease * 0x7) >> 3; temp_addr.s_addr = packet.yiaddr; LOG(LOG_INFO, "Lease of %s obtained, lease time %ld", inet_ntoa(temp_addr), lease); start = now; timeout = t1 + start; requested_ip = packet.yiaddr; run_script(&packet, ((state == RENEWING || state == REBINDING) ? "renew" : "bound")); state = BOUND; change_mode(LISTEN_NONE); if (client_config.quit_after_lease) exit_client(0); if (!client_config.foreground) background(); } else if (*message == DHCPNAK) { /* return to init state */ LOG(LOG_INFO, "Received DHCP NAK"); run_script(&packet, "nak"); if (state != REQUESTING) run_script(NULL, "deconfig"); state = INIT_SELECTING; timeout = now; requested_ip = 0; packet_num = 0; change_mode(LISTEN_RAW); sleep(3); /* avoid excessive network traffic */ } break; /* case BOUND, RELEASED: - ignore all packets */ } } else if (retval > 0 && FD_ISSET(signal_pipe[0], &rfds)) {
/* * create_object parse the object fields from the command line and call the * appropriate object creator with a table of fields filled in. */ int main( int argc, char **argv) { int ret = 0; int parse_err = 0; int index = 1; int c; char *obj_type; char *configFile = NULL; extern char *optarg; struct object_field *table; OPEN_LOG("create_object", LOG_USER); if (!my_config_load()) { LOG(LOG_ERR, "can't load configuration"); return EXIT_FAILURE; } // parse options while ((c = getopt(argc, argv, "hf:t:")) != -1) { switch (c) { case 'h': printUsage(argv); break; case 'f': configFile = optarg; break; case 't': templateFile = optarg; break; case '?': printUsage(argv); break; default: fprintf(stderr, "Illegal Option\n"); printUsage(argv); break; } } index = optind; // remaining arguments if (configFile == NULL) fprintf(stdout, "No Config file\n"); if (index >= argc) fatal(INPUT_ARG_ERR, "No Object Type"); else obj_type = argv[index++]; if (strncasecmp(obj_type, "CERT", strlen("CERT")) == 0) { table = get_cert_field_table(); if (configFile != NULL) if (parse_config(configFile, table) != 0) { warn(INPUT_ARG_ERR, parse_errstr); parse_err = 1; } // parse and validate arguments, exit if either or both fail if (parse_args(argc, argv, index, table) != 0) { warn(INPUT_ARG_ERR, parse_errstr); parse_err = 1; } if (validate_table(table, validate_errstr, sizeof(validate_errstr)) != 0) fatal(MISSING_FIELDS, validate_errstr); // if no validation error but we did have a parse err - exit if (parse_err) { config_unload(); exit(INPUT_ARG_ERR); } ret = create_cert(table); // fprintf(stdout,"return from creating certificate %d\n", ret); } else if (strncasecmp(obj_type, "CRL", strlen("CRL")) == 0) { table = get_crl_field_table(); if (configFile != NULL) if (parse_config(configFile, table) != 0) { warn(INPUT_ARG_ERR, parse_errstr); parse_err = 1; } if (parse_args(argc, argv, index, table) != 0) { warn(INPUT_ARG_ERR, parse_errstr); parse_err = 1; } if (validate_table(table, validate_errstr, sizeof(validate_errstr)) != 0) fatal(MISSING_FIELDS, validate_errstr); // if no validation error but we did have a parse err - exit if (parse_err) { config_unload(); exit(INPUT_ARG_ERR); } ret = create_crl(table); } else if (strncasecmp(obj_type, "ROA", strlen("ROA")) == 0) { table = get_roa_field_table(); if (configFile != NULL) if (parse_config(configFile, table) != 0) { warn(INPUT_ARG_ERR, parse_errstr); parse_err = 1; } if (parse_args(argc, argv, index, table) != 0) fatal(INPUT_ARG_ERR, parse_errstr); if (validate_table(table, validate_errstr, sizeof(validate_errstr)) != 0) fatal(MISSING_FIELDS, validate_errstr); ret = create_roa(table); } else if (strncasecmp(obj_type, "MANIFEST", strlen("MANIFEST")) == 0) { table = get_man_field_table(); if (configFile != NULL) if (parse_config(configFile, table) != 0) { warn(INPUT_ARG_ERR, parse_errstr); parse_err = 1; } // parse arguments and validate table if (parse_args(argc, argv, index, table) != 0) warn(INPUT_ARG_ERR, parse_errstr); if (validate_table(table, validate_errstr, sizeof(validate_errstr)) != 0) fatal(MISSING_FIELDS, validate_errstr); ret = create_manifest(table); } else fatal(INPUT_ARG_ERR, argv[1]); config_unload(); exit(ret); }
int main(int argc, char *argv[]) #endif { fd_set rfds; struct timeval tv; int server_socket = -1; int bytes, retval; struct dhcpMessage packet; unsigned char *state; unsigned char *server_id, *requested, *hostname; u_int32_t server_id_align, requested_align; unsigned long timeout_end; struct option_set *option; struct dhcpOfferedAddr *lease; int pid_fd; int max_sock; int sig; OPEN_LOG("udhcpd"); LOG(LOG_INFO, "udhcp server (v%s) started", VERSION); memset(&server_config, 0, sizeof(struct server_config_t)); if (argc < 2) read_config(DHCPD_CONF_FILE); else read_config(argv[1]); pid_fd = pidfile_acquire(server_config.pidfile); pidfile_write_release(pid_fd); if ((option = find_option(server_config.options, DHCP_LEASE_TIME))) { memcpy(&server_config.lease, option->data + 2, 4); server_config.lease = ntohl(server_config.lease); } else server_config.lease = LEASE_TIME; leases = malloc(sizeof(struct dhcpOfferedAddr) * server_config.max_leases); memset(leases, 0, sizeof(struct dhcpOfferedAddr) * server_config.max_leases); // Added by Joey to load static lease if (argc>=3) { load_leases(argv[2]); } read_leases(server_config.lease_file); if (read_interface(server_config.interface, &server_config.ifindex, &server_config.server, server_config.arp) < 0) exit_server(1); #ifndef DEBUGGING pid_fd = pidfile_acquire(server_config.pidfile); /* hold lock during fork. */ if (daemon(0, 0) == -1) { perror("fork"); exit_server(1); } pidfile_write_release(pid_fd); #endif /* ensure that stdin/stdout/stderr are never returned by pipe() */ if (fcntl(STDIN_FILENO, F_GETFL) == -1) (void) open("/dev/null", O_RDONLY); if (fcntl(STDOUT_FILENO, F_GETFL) == -1) (void) open("/dev/null", O_WRONLY); if (fcntl(STDERR_FILENO, F_GETFL) == -1) (void) open("/dev/null", O_WRONLY); /* setup signal handlers */ pipe(signal_pipe); signal(SIGUSR1, signal_handler); signal(SIGTERM, signal_handler); timeout_end = uptime() + server_config.auto_time; while(1) { /* loop until universe collapses */ if (server_socket < 0) if ((server_socket = listen_socket(INADDR_ANY, SERVER_PORT, server_config.interface)) < 0) { LOG(LOG_ERR, "FATAL: couldn't create server socket, %s", strerror(errno)); exit_server(0); } FD_ZERO(&rfds); FD_SET(server_socket, &rfds); FD_SET(signal_pipe[0], &rfds); if (server_config.auto_time) { tv.tv_sec = timeout_end - uptime(); tv.tv_usec = 0; } if (!server_config.auto_time || tv.tv_sec > 0) { max_sock = server_socket > signal_pipe[0] ? server_socket : signal_pipe[0]; retval = select(max_sock + 1, &rfds, NULL, NULL, server_config.auto_time ? &tv : NULL); } else retval = 0; /* If we already timed out, fall through */ if (retval == 0) { write_leases(); timeout_end = uptime() + server_config.auto_time; continue; } else if (retval < 0 && errno != EINTR) { DEBUG(LOG_INFO, "error on select"); continue; } if (FD_ISSET(signal_pipe[0], &rfds)) { if (read(signal_pipe[0], &sig, sizeof(sig)) < 0) continue; /* probably just EINTR */ switch (sig) { case SIGUSR1: LOG(LOG_INFO, "Received a SIGUSR1"); write_leases(); /* why not just reset the timeout, eh */ timeout_end = uptime() + server_config.auto_time; continue; case SIGTERM: LOG(LOG_INFO, "Received a SIGTERM"); exit_server(0); } } if ((bytes = get_packet(&packet, server_socket)) < 0) { /* this waits for a packet - idle */ if (bytes == -1 && errno != EINTR) { DEBUG(LOG_INFO, "error on read, %s, reopening socket", strerror(errno)); close(server_socket); server_socket = -1; } continue; } if ((state = get_option(&packet, DHCP_MESSAGE_TYPE)) == NULL) { DEBUG(LOG_ERR, "couldn't get option from packet, ignoring"); continue; } server_id = get_option(&packet, DHCP_SERVER_ID); if (server_id) { memcpy(&server_id_align, server_id, 4); if (server_id_align != server_config.server) { /* client talks to somebody else */ DEBUG(LOG_INFO,"server ID %08x doesn't match, ignoring", ntohl(server_id_align)); continue; } } /* ADDME: look for a static lease */ lease = find_lease_by_chaddr(packet.chaddr); switch (state[0]) { case DHCPDISCOVER: DEBUG(LOG_INFO,"received DISCOVER"); if (sendOffer(&packet) < 0) { LOG(LOG_ERR, "send OFFER failed"); } break; case DHCPREQUEST: DEBUG(LOG_INFO, "received REQUEST"); requested = get_option(&packet, DHCP_REQUESTED_IP); hostname = get_option(&packet, DHCP_HOST_NAME); if (requested) memcpy(&requested_align, requested, 4); if (lease) { /*ADDME: or static lease */ if (server_id) { /* SELECTING State */ if (requested && requested_align == lease->yiaddr) { sendACK(&packet, lease->yiaddr); } } else { if (requested) { /* INIT-REBOOT State */ if (lease->yiaddr == requested_align) sendACK(&packet, lease->yiaddr); else sendNAK(&packet); } else { /* RENEWING or REBINDING State */ if (lease->yiaddr == packet.ciaddr) sendACK(&packet, lease->yiaddr); else { /* don't know what to do!!!! */ sendNAK(&packet); } } } if (hostname) { bytes = hostname[-1]; if (bytes >= (int) sizeof(lease->hostname)) bytes = sizeof(lease->hostname) - 1; strncpy(lease->hostname, hostname, bytes); lease->hostname[bytes] = '\0'; if (!is_valid_hostname(lease->hostname)) lease->hostname[0] = '\0'; } else lease->hostname[0] = '\0'; /* what to do if we have no record of the client */ } else if (server_id) { /* SELECTING State */ if (requested) sendNAK(&packet); } else if (requested) { /* INIT-REBOOT State */ if ((lease = find_lease_by_yiaddr(requested_align))) { if (lease_expired(lease)) { /* probably best if we drop this lease */ memset(lease->chaddr, 0, 16); /* make some contention for this address */ } else sendNAK(&packet); } else if (requested_align < server_config.start || requested_align > server_config.end) { sendNAK(&packet); } else { sendNAK(&packet); } } else if (packet.ciaddr) { /* RENEWING or REBINDING State */ sendNAK(&packet); } break; case DHCPDECLINE: DEBUG(LOG_INFO,"received DECLINE"); if (lease) { memset(lease->chaddr, 0, 16); lease->expires = uptime() + server_config.decline_time; } break; case DHCPRELEASE: DEBUG(LOG_INFO,"received RELEASE"); if (lease) lease->expires = uptime(); break; case DHCPINFORM: DEBUG(LOG_INFO,"received INFORM"); send_inform(&packet); break; default: LOG(LOG_WARNING, "unsupported DHCP message (%02x) -- ignoring", state[0]); } } return 0; }