static void *correct_thread(void *data) { correct_aux_t *d = (correct_aux_t*) data; int i = 0; bwa_seq_t *s = NULL, *query = NULL, *seqs = d->ht->seqs; readarray *low_kmer_reads = d->low_kmer_reads; alignarray *aligns = NULL; aligns = g_ptr_array_sized_new(N_DEFAULT_ALIGNS); for (i = d->start; i < d->end; i++) { if (i % 10000 == 0) show_msg(__func__, "Thread %d correction progress: [%d,%d,%d]... \n", d->tid, d->start, i, d->end); s = g_ptr_array_index(low_kmer_reads, i); if (is_repetitive_q(s)) { s->status = USED; continue; } // Only the fresh reads, or the reads tried once would be corrected. if (s->status != FRESH) continue; query = new_seq(s, s->len - 8, 0); pe_aln_query(s, s->seq, d->ht, MISMATCHES, s->len, 0, aligns); pe_aln_query(s, s->rseq, d->ht, MISMATCHES, s->len, 1, aligns); if (aligns->len >= 4) correct_bases(seqs, s, aligns, d->tid); s->status = TRIED; reset_alg(aligns); bwa_free_read_seq(1, query); //if (i > 10000) // break; } free_alg(aligns); show_msg(__func__, "Thread %d finished. \n", d->tid); }
static int recv_buffer(struct connreq *conn) { int rc = 0; show_msg(MSGDEBUG, "Reading from server (expecting %d bytes)\n", conn->datalen); while ((rc == 0) && (conn->datadone != conn->datalen)) { rc = recv(conn->sockid, conn->buffer + conn->datadone, conn->datalen - conn->datadone, 0); if (rc > 0) { conn->datadone += rc; rc = 0; } else if (rc == 0) { show_msg(MSGDEBUG, "Peer has shutdown but we only read %d of %d bytes.\n", conn->datadone, conn->datalen); rc = ENOTCONN; /* ENOTCONN seems like the most fitting error message */ } else { if (errno != EWOULDBLOCK) show_msg(MSGDEBUG, "Read failed, %s\n", strerror(errno)); rc = errno; } } if (conn->datadone == conn->datalen) conn->state = conn->nextstate; show_msg(MSGDEBUG, "Received %d bytes of %d bytes expected, return code is %d\n", conn->datadone, conn->datalen, rc); return(rc); }
static int handle_path(struct parsedfile *config, int lineno, int nowords, char *words[]) { struct serverent *newserver; if ((nowords != 2) || (strcmp(words[1], "{"))) { show_msg(MSGERR, "Badly formed path open statement on line %d " "in configuration file (should look like " "\"path {\")\n", lineno); } else if (currentcontext != &(config->defaultserver)) { /* You cannot nest path statements so check that */ /* the current context is defaultserver */ show_msg(MSGERR, "Path statements cannot be nested on line %d " "in configuration file\n", lineno); } else { /* Open up a new serverent, put it on the list */ /* then set the current context */ if (((int) (newserver = (struct serverent *) malloc(sizeof(struct serverent)))) == -1) exit(-1); /* Initialize the structure */ show_msg(MSGDEBUG, "New server structure from line %d in configuration file going " "to 0x%08x\n", lineno, newserver); memset(newserver, 0x0, sizeof(*newserver)); newserver->next = config->paths; newserver->lineno = lineno; config->paths = newserver; currentcontext = newserver; } return(0); }
/* If we are not done setting up the connection yet, return * -1 and ENOTCONN, otherwise call getpeername * * This is necessary since some applications, when using non-blocking connect, * (like ircII) use getpeername() to find out if they are connected already. * * This results in races sometimes, where the client sends data to the socket * before we are done with the socks connection setup. Another solution would * be to intercept send(). * * This could be extended to actually set the peername to the peer the * client application has requested, but not for now. * * PP, Sat, 27 Mar 2004 11:30:23 +0100 */ int getpeername(GETPEERNAME_SIGNATURE) { struct connreq *conn; int rc; if (realgetpeername == NULL) { show_msg(MSGERR, "Unresolved symbol: getpeername\n"); return(-1); } show_msg(MSGDEBUG, "Call to getpeername for fd %d\n", __fd); rc = realgetpeername(__fd, __name, __namelen); if (rc == -1) return rc; /* Are we handling this connect? */ if ((conn = find_socks_request(__fd, 1))) { /* While we are at it, we might was well try to do something useful */ handle_request(conn); if (conn->state != DONE) { errno = ENOTCONN; return(-1); } } return rc; }
static int handle_type(struct parsedfile *config, int lineno, char *value) { if (currentcontext->type != 0) { if (currentcontext == &(config->defaultserver)) show_msg(MSGERR, "Server type may only be specified " "once for default server, at line %d " "in configuration file\n", lineno); else show_msg(MSGERR, "Server type may only be specified " "once per path on line %d in configuration " "file. (Path begins on line %d)\n", lineno, currentcontext->lineno); } else { errno = 0; currentcontext->type = (int) strtol(value, (char **)NULL, 10); if ((errno != 0) || (currentcontext->type == 0) || ((currentcontext->type != 4) && (currentcontext->type != 5))) { show_msg(MSGERR, "Invalid server type (%s) " "specified in configuration file " "on line %d, only 4 or 5 may be " "specified\n", value, lineno); currentcontext->type = 0; } } return(0); }
struct hostent * our_gethostbyname(dead_pool *pool, const char *name) { int pos; static struct in_addr addr; static struct hostent he; static char *addrs[2]; show_msg(MSGDEBUG, "our_gethostbyname: '%s' requested\n", name); pos = store_pool_entry(pool,(char *) name, &addr); if(pos == -1) { h_errno = HOST_NOT_FOUND; return NULL; } addrs[0] = (char *)&addr; addrs[1] = NULL; he.h_name = pool->entries[pos].name; he.h_aliases = NULL; he.h_length = 4; he.h_addrtype = AF_INET; he.h_addr_list = addrs; show_msg(MSGDEBUG, "our_gethostbyname: resolved '%s' to: '%s'\n", name, inet_ntoa(*((struct in_addr *)he.h_addr))); return &he; }
static int parse_socks4a_resolve_response(const char *response, size_t len, uint32_t *addr_out) { uint8_t status; uint16_t port; if (len < RESPONSE_LEN) { show_msg(MSGWARN,"Truncated socks response.\n"); return -1; } if (((uint8_t)response[0])!=0) { /* version: 0 */ show_msg(MSGWARN,"Nonzero version in socks response: bad format.\n"); return -1; } status = (uint8_t)response[1]; memcpy(&port, response+2, sizeof(port)); if (port!=0) { /* port: 0 */ show_msg(MSGWARN,"Nonzero port in socks response: bad format.\n"); return -1; } if (status != 90) { show_msg(MSGWARN,"Bad status: socks request failed.\n"); return -1; } memcpy(addr_out, response+4, sizeof(*addr_out)); return 0; }
bwa_seq_t *load_reads(const char *fa_fn, uint32_t *n_seqs) { bwa_seq_t *seqs, *part_seqs; bwa_seqio_t *ks; int n_part_seqs = 0, n_seqs_full = 0, n_seqs_loaded = 0; clock_t t = clock(); ks = bwa_open_reads(BWA_MODE, fa_fn); n_seqs_full = N_CHUNK_SEQS; show_msg(__func__, "Loading reads from library %s...\n", fa_fn); seqs = (bwa_seq_t*) calloc (N_DF_MAX_SEQS, sizeof(bwa_seq_t)); while ((part_seqs = bwa_read_seq(ks, N_CHUNK_SEQS, &n_part_seqs, BWA_MODE, 0)) != 0) { show_msg(__func__, "%d sequences loaded: %.2f sec... \n", n_seqs_loaded + n_part_seqs, fa_fn, (float) (clock() - t) / CLOCKS_PER_SEC); pe_reverse_seqs(part_seqs, n_part_seqs); if ((n_seqs_loaded + n_part_seqs) > n_seqs_full) { n_seqs_full += n_part_seqs + 2; kroundup32(n_seqs_full); seqs = (bwa_seq_t*) realloc(seqs, sizeof(bwa_seq_t) * n_seqs_full); } memmove(&seqs[n_seqs_loaded], part_seqs, sizeof(bwa_seq_t) * n_part_seqs); free(part_seqs); n_seqs_loaded += n_part_seqs; } bwa_seq_close(ks); if (n_seqs_loaded < 1) { err_fatal(__func__, "No sequence in file %s, make sure the format is correct! \n", fa_fn); } *n_seqs = n_seqs_loaded; return seqs; }
static int read_socksv4_req(struct connreq *conn) { struct sockrep *thisrep; thisrep = (struct sockrep *) conn->buffer; if (thisrep->result != 90) { show_msg(MSGERR, "SOCKS V4 connect rejected:\n"); conn->state = FAILED; switch(thisrep->result) { case 91: show_msg(MSGERR, "SOCKS server refused connection\n"); return(ECONNREFUSED); case 92: show_msg(MSGERR, "SOCKS server refused connection " "because of failed connect to identd " "on this machine\n"); return(ECONNREFUSED); case 93: show_msg(MSGERR, "SOCKS server refused connection " "because identd and this library " "reported different user-ids\n"); return(ECONNREFUSED); default: show_msg(MSGERR, "Unknown reason\n"); return(ECONNREFUSED); } } conn->state = DONE; return(0); }
static int handle_port(struct parsedfile *config, int lineno, char *value) { if (currentcontext->port != 0) { if (currentcontext == &(config->defaultserver)) show_msg(MSGERR, "Server port may only be specified " "once for default server, at line %d " "in configuration file\n", lineno); else show_msg(MSGERR, "Server port may only be specified " "once per path on line %d in configuration " "file. (Path begins on line %d)\n", lineno, currentcontext->lineno); } else { errno = 0; currentcontext->port = (unsigned short int) (strtol(value, (char **)NULL, 10)); if ((errno != 0) || (currentcontext->port == 0)) { show_msg(MSGERR, "Invalid server port number " "specified in configuration file " "(%s) on line %d\n", value, lineno); currentcontext->port = 0; } } return(0); }
static int connect_server(struct connreq *conn) { int rc; /* Connect this socket to the socks server */ show_msg(MSGDEBUG, "Connecting to %s port %d\n", inet_ntoa(conn->serveraddr.sin_addr), ntohs(conn->serveraddr.sin_port)); rc = realconnect(conn->sockid, (CONNECT_SOCKARG) &(conn->serveraddr), sizeof(conn->serveraddr)); show_msg(MSGDEBUG, "Connect returned %d, errno is %d\n", rc, errno); if (rc) { if (errno != EINPROGRESS) { show_msg(MSGERR, "Error %d attempting to connect to SOCKS " "server (%s)\n", errno, strerror(errno)); conn->state = FAILED; } else { show_msg(MSGDEBUG, "Connection in progress\n"); conn->state = CONNECTING; } } else { show_msg(MSGDEBUG, "Socket %d connected to SOCKS server\n", conn->sockid); conn->state = CONNECTED; } return((rc ? errno : 0)); }
static ssize_t client_receive_smb(struct cli_state *cli, size_t maxlen) { size_t len; for(;;) { NTSTATUS status; set_smb_read_error(&cli->smb_rw_error, SMB_READ_OK); status = receive_smb_raw(cli->fd, cli->inbuf, cli->bufsize, cli->timeout, maxlen, &len); if (!NT_STATUS_IS_OK(status)) { DEBUG(10,("client_receive_smb failed\n")); show_msg(cli->inbuf); if (NT_STATUS_EQUAL(status, NT_STATUS_END_OF_FILE)) { set_smb_read_error(&cli->smb_rw_error, SMB_READ_EOF); return -1; } if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) { set_smb_read_error(&cli->smb_rw_error, SMB_READ_TIMEOUT); return -1; } set_smb_read_error(&cli->smb_rw_error, SMB_READ_ERROR); return -1; } /* * I don't believe len can be < 0 with NT_STATUS_OK * returned above, but this check doesn't hurt. JRA. */ if ((ssize_t)len < 0) { return len; } /* Ignore session keepalive packets. */ if(CVAL(cli->inbuf,0) != SMBkeepalive) { break; } } if (cli_encryption_on(cli)) { NTSTATUS status = cli_decrypt_message(cli); if (!NT_STATUS_IS_OK(status)) { DEBUG(0, ("SMB decryption failed on incoming packet! Error %s\n", nt_errstr(status))); cli->smb_rw_error = SMB_READ_BAD_DECRYPT; return -1; } } show_msg(cli->inbuf); return len; }
static int handle_line(struct parsedfile *config, char *line, int lineno) { char *words[10]; static char savedline[MAXLINE]; int nowords = 0, i; /* Save the input string */ strncpy(savedline, line, MAXLINE - 1); savedline[MAXLINE - 1] = (char) 0; /* Tokenize the input string */ nowords = tokenize(line, 10, words); /* Set the spare slots to an empty string to simplify */ /* processing */ for (i = nowords; i < 10; i++) words[i] = ""; if (nowords > 0) { /* Now this can either be a "path" block starter or */ /* ender, otherwise it has to be a pair (<name> = */ /* <value>) */ if (!strcmp(words[0], "path")) { handle_path(config, lineno, nowords, words); } else if (!strcmp(words[0], "}")) { handle_endpath(config, lineno, nowords, words); } else { /* Has to be a pair */ if ((nowords != 3) || (strcmp(words[1], "="))) { show_msg(MSGERR, "Malformed configuration pair " "on line %d in configuration " "file, \"%s\"\n", lineno, savedline); } else if (!strcmp(words[0], "reaches")) { handle_reaches(config, lineno, words[2]); } else if (!strcmp(words[0], "server")) { handle_server(config, lineno, words[2]); } else if (!strcmp(words[0], "server_port")) { handle_port(config, lineno, words[2]); } else if (!strcmp(words[0], "server_type")) { handle_type(config, lineno, words[2]); } else if (!strcmp(words[0], "default_user")) { handle_defuser(config, lineno, words[2]); } else if (!strcmp(words[0], "default_pass")) { handle_defpass(config, lineno, words[2]); } else if (!strcmp(words[0], "local")) { handle_local(config, lineno, words[2]); } else { show_msg(MSGERR, "Invalid pair type (%s) specified " "on line %d in configuration file, " "\"%s\"\n", words[0], lineno, savedline); } } } return(0); }
static int send_socksv5_connect(struct connreq *conn) { #ifdef USE_TOR_DNS int namelen = 0; char *name = NULL; #endif char constring[] = { 0x05, /* Version 5 SOCKS */ 0x01, /* Connect request */ 0x00, /* Reserved */ 0x01 }; /* IP Version 4 */ show_msg(MSGDEBUG, "Constructing V5 connect request\n"); conn->datadone = 0; conn->state = SENDING; conn->nextstate = SENTV5CONNECT; memcpy(conn->buffer, constring, sizeof(constring)); conn->datalen = sizeof(constring); #ifdef USE_TOR_DNS show_msg(MSGDEBUG, "send_socksv5_connect: looking for: %s\n", inet_ntoa(conn->connaddr.sin_addr)); name = get_pool_entry(pool, &(conn->connaddr.sin_addr)); if(name != NULL) { namelen = strlen(name); if(namelen > 255) { /* "Can't happen" */ name = NULL; } } if(name != NULL) { show_msg(MSGDEBUG, "send_socksv5_connect: found it!\n"); /* Substitute the domain name from the pool into the SOCKS request. */ conn->buffer[3] = 0x03; /* Change the ATYP field */ conn->buffer[4] = namelen; /* Length of name */ conn->datalen++; memcpy(&conn->buffer[conn->datalen], name, namelen); conn->datalen += namelen; } else { show_msg(MSGDEBUG, "send_socksv5_connect: ip address not found\n"); #endif /* Use the raw IP address */ memcpy(&conn->buffer[conn->datalen], &(conn->connaddr.sin_addr.s_addr), sizeof(conn->connaddr.sin_addr.s_addr)); conn->datalen += sizeof(conn->connaddr.sin_addr.s_addr); #ifdef USE_TOR_DNS } #endif memcpy(&conn->buffer[conn->datalen], &(conn->connaddr.sin_port), sizeof(conn->connaddr.sin_port)); conn->datalen += sizeof(conn->connaddr.sin_port); return(0); }
static int handle_reaches(int lineno, char *value) { int rc; struct netent *ent; rc = make_netent(value, &ent); switch(rc) { case 1: show_msg(MSGERR, "Local network specification (%s) is not validly " "constructed in reach statement on line " "%d in configuration " "file\n", value, lineno); return(0); break; case 2: show_msg(MSGERR, "IP in reach statement " "network specification (%s) is not valid on line " "%d in configuration file\n", value, lineno); return(0); break; case 3: show_msg(MSGERR, "SUBNET in reach statement " "network specification (%s) is not valid on " "line %d in configuration file\n", value, lineno); return(0); break; case 4: show_msg(MSGERR, "IP (%s) & ", inet_ntoa(ent->localip)); show_msg(MSGERR, "SUBNET (%s) != IP on line %d in " "configuration file, ignored\n", inet_ntoa(ent->localnet), lineno); return(0); break; case 5: show_msg(MSGERR, "Start port in reach statement " "network specification (%s) is not valid on line " "%d in configuration file\n", value, lineno); return(0); break; case 6: show_msg(MSGERR, "End port in reach statement " "network specification (%s) is not valid on line " "%d in configuration file\n", value, lineno); return(0); break; case 7: show_msg(MSGERR, "End port in reach statement " "network specification (%s) is less than the start " "port on line %d in configuration file\n", value, lineno); return(0); break; } /* The entry is valid so add it to linked list */ ent -> next = currentcontext -> reachnets; currentcontext -> reachnets = ent; return(0); }
void STATS_ITEM::sample(double v, bool collecting_stats, double now) { if (value != v && log_changes) { char buf[256]; switch (kind) { case DISK: sprintf(buf, "%s: %f GB -> %f GB\n", name, value/1e9, v/1e9); show_msg(buf); break; case NETWORK: sprintf(buf, "%s: %f Mbps -> %f Mbps\n", name, value/1e6, v/1e6); show_msg(buf); break; case FAULT_TOLERANCE: sprintf(buf, "%s: %.0f -> %.0f\n", name, value, v); show_msg(buf); break; } } double old_val = value; value = v; if (!collecting_stats) return; if (first) { first = false; prev_t = now; return; } double dt = now - prev_t; prev_t = now; integral += dt*old_val; switch (kind) { case DISK: case NETWORK: if (v > extreme_val) { extreme_val = v; extreme_val_time = now; } break; case FAULT_TOLERANCE: if (v < extreme_val) { extreme_val = v; extreme_val_time = now; } break; } fprintf(f, "%f %f\n", now, old_val); fprintf(f, "%f %f\n", now, v); }
static BOOL reply_sesssetup_blob(connection_struct *conn, char *outbuf, DATA_BLOB blob, NTSTATUS nt_status) { char *p; if (!NT_STATUS_IS_OK(nt_status) && !NT_STATUS_EQUAL(nt_status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { ERROR_NT(nt_status_squash(nt_status)); } else { set_message(outbuf,4,0,True); nt_status = nt_status_squash(nt_status); SIVAL(outbuf, smb_rcls, NT_STATUS_V(nt_status)); SSVAL(outbuf, smb_vwv0, 0xFF); /* no chaining possible */ SSVAL(outbuf, smb_vwv3, blob.length); p = smb_buf(outbuf); /* should we cap this? */ memcpy(p, blob.data, blob.length); p += blob.length; p += add_signature( outbuf, p ); set_message_end(outbuf,p); } show_msg(outbuf); return send_smb(smbd_server_fd(),outbuf); }
static int get_config () { static int done = 0; if (done) return(0); /* Determine the location of the config file */ #ifdef ALLOW_ENV_CONFIG if (!suid) conffile = getenv("TSOCKS_CONF_FILE"); #endif /* Read in the config file */ config = malloc(sizeof(*config)); if (!config) return(0); read_config(conffile, config); if (config->paths) show_msg(MSGDEBUG, "First lineno for first path is %d\n", config->paths->lineno); done = 1; return(0); }
int main(void) { FILE *fp; std_t *stdp = NULL; int choice, len; fp = fopen("student_score", "r+"); if(fp == NULL) sys_err("fopen student_score"); stdp = get_info(fp, stdp, &len); while(1){ show_msg(1); scanf("%d", &choice); switch(choice){ case 1:display(stdp, len); break; case 2:sort(stdp, len, 1); break; case 3:insert(stdp, len, fp); break; case 4:sort(stdp, len, 2); free(stdp); fclose(fp); return 0; default:fputs("Invalid choice, rechoose!\n", stdout); break; } } return 0; }
static int send_socksv4_request(struct connreq *conn) { struct passwd *user; struct sockreq *thisreq; /* Determine the current username */ user = getpwuid(getuid()); thisreq = (struct sockreq *) conn->buffer; /* Check the buffer has enough space for the request */ /* and the user name */ conn->datalen = sizeof(struct sockreq) + (user == NULL ? 0 : strlen(user->pw_name)) + 1; if (sizeof(conn->buffer) < conn->datalen) { show_msg(MSGERR, "The SOCKS username is too long"); conn->state = FAILED; return(ECONNREFUSED); } /* Create the request */ thisreq->version = 4; thisreq->command = 1; thisreq->dstport = conn->connaddr.sin_port; thisreq->dstip = conn->connaddr.sin_addr.s_addr; /* Copy the username */ strcpy((char *) thisreq + sizeof(struct sockreq), (user == NULL ? "" : user->pw_name)); conn->datadone = 0; conn->state = SENDING; conn->nextstate = SENTV4REQ; return(0); }
void display(std_t *stdp, int len) { int i; show_msg(2); for(i = 0; i < len; i++){ printf("%u\t%s\t%d\t%d\t%.2f\n", stdp[i].id, stdp[i].name, stdp[i].math, stdp[i].eng, (stdp[i].math + stdp[i].eng) / 2.0); } }
void mc_warn (const char *s, ...) { va_list argp; va_start (argp, s); show_msg ("warning", s, argp); va_end (argp); }
// Timer event when status update operation times out void status_change_timeout(void *data) { reset_inactivity_timer(); status_change_timeout_timer = NULL; s_device_status_target = DSNone; cancel_status_check(); show_device_status(s_device_status, s_status_changed); show_msg("Operation timed out", false, 5); }
void show() { char tmfmt[] = " %2$s\n\0\0%s%s\n\0\0\0\0\0\0\0\0\0\0\0"; time_t tim; struct tm* tm; char buf[80]; time(&tim); tm = localtime(&tim); strftime(buf, 80, "%H:%M:%S ", tm); if (g_ptim != tim) { g_ptim = tim; show_msg(buf, tmfmt + 16); } else { show_msg(buf, tmfmt); } }
struct hostent * our_gethostbyaddr(dead_pool *pool, const void *_addr, socklen_t len, int type) { const struct in_addr *addr=_addr; static struct hostent he; uint32_t intaddr=0; char *result_hostname=NULL; int rc=0; static char *addrs[2]; static char *aliases[2]; rc = do_resolve("", pool->sockshost, pool->socksport, &intaddr, addr, 5 /*SOCKS5*/, 1 /*Reverse*/, &result_hostname); if(rc != 0) { show_msg(MSGWARN, "failed to reverse resolve: %s\n", inet_ntoa(*((struct in_addr *)addr))); result_hostname=NULL; addrs[0] = NULL; addrs[1] = NULL; }else{ addrs[0] = (char *)addr; addrs[1] = NULL; } if (result_hostname) he.h_name = result_hostname; else he.h_name = inet_ntoa(*((struct in_addr *)addr)); aliases[0] = NULL; aliases[1] = NULL; he.h_aliases = aliases; he.h_length = len; he.h_addrtype = type; he.h_addr_list = addrs; show_msg(MSGDEBUG, "our_gethostbyaddr: resolved '%s' to: '%s'\n", inet_ntoa(*((struct in_addr *)he.h_addr)), result_hostname); return &he; }
void mc_fatal (const char *s, ...) { va_list argp; va_start (argp, s); show_msg ("fatal", s, argp); va_end (argp); xexit (1); }
int yyerror (const char *s, ...) { va_list argp; va_start (argp, s); show_msg ("parser", s, argp); va_end (argp); return 1; }
static int handle_defpass(struct parsedfile *config, int lineno, char *value) { if (currentcontext->defpass != NULL) { if (currentcontext == &(config->defaultserver)) show_msg(MSGERR, "Default password may only be specified " "once for default server, at line %d " "in configuration file\n", lineno); else show_msg(MSGERR, "Default password may only be specified " "once per path on line %d in configuration " "file. (Path begins on line %d)\n", lineno, currentcontext->lineno); } else { currentcontext->defpass = strdup(value); } return(0); }
int read_config (char *filename, struct parsedfile *config) { FILE *conf; char line[MAXLINE]; int rc = 0; int lineno = 1; struct serverent *server; /* Clear out the structure */ memset(config, 0x0, sizeof(*config)); /* Initialization */ currentcontext = &(config->defaultserver); /* If a filename wasn't provided, use the default */ if (filename == NULL) { strncpy(line, CONF_FILE, sizeof(line) - 1); /* Insure null termination */ line[sizeof(line) - 1] = (char) 0; filename = line; } /* Read the configuration file */ if ((conf = fopen(filename, "r")) == NULL) { show_msg(MSGERR, "Could not open socks configuration file " "(%s), assuming all networks local\n", filename); handle_local(config, 0, "0.0.0.0/0.0.0.0"); rc = 1; /* Severe errors reading configuration */ } else { memset(&(config->defaultserver), 0x0, sizeof(config->defaultserver)); while (NULL != fgets(line, MAXLINE, conf)) { /* This line _SHOULD_ end in \n so we */ /* just chop off the \n and hand it on */ if (strlen(line) > 0) line[strlen(line) - 1] = '\0'; handle_line(config, line, lineno); lineno++; } fclose(conf); /* Always add the 127.0.0.1/255.0.0.0 subnet to local */ handle_local(config, 0, "127.0.0.0/255.0.0.0"); /* Check default server */ check_server(&(config->defaultserver)); server = (config->paths); while (server != NULL) { check_server(server); server = server->next; } } return(rc); }
int main(int argc, char *argv[]) { const char *usage = "Usage: [-f conf file] [-t hostname/ip[:port]]"; char *filename = NULL; char *testhost = NULL; struct parsedfile config; int i; if ((argc > 5) || (((argc - 1) % 2) != 0)) { show_msg(MSGERR, "Invalid number of arguments\n"); show_msg(MSGERR, "%s\n", usage); exit(1); } for (i = 1; i < argc; i = i + 2) { if (!strcmp(argv[i], "-f")) { filename = argv[(i + 1)]; } else if (!strcmp(argv[i], "-t")) { testhost = argv[(i + 1)]; } else { show_msg(MSGERR, "Unknown option %s\n", argv[i]); show_msg(MSGERR, "%s\n", usage); exit(1); } } if (!filename) filename = strdup(CONF_FILE); printf("Reading configuration file %s...\n", filename); if (read_config(filename, &config) == 0) printf("... Read complete\n\n"); else exit(1); /* If they specified a test host, test it, otherwise */ /* dump the configuration */ if (!testhost) show_conf(&config); else test_host(&config, testhost); return(0); }