static void Acceptor(int listenfd) { FILE *fp = fdopen(listenfd, "w+"); if (fp) { handle_socket(fp); fflush(fp); fclose(fp); } }
int command_link(struct debugger_state *state, int argc, char **argv) { if (argc < 3) { state->print(state, "%s [send|recv|socket] [value|behavior|path]\n" "send a value will send a value to the link port. If you pass a file, it will be sent instead.\n" "recv [behavior] defines z80e's behavior when receiving link port data.\n" "Use 'print' to print each value, or a file name to write values to that file.\n", argv[0]); return 0; } if (strcasecmp(argv[1], "send") == 0) { return handle_send(state, argc, argv); } else if (strcasecmp(argv[1], "recv") == 0) { return handle_recv(state, argc, argv); } else if (strcasecmp(argv[1], "socket") == 0) { return handle_socket(state, argc, argv); } else { state->print(state, "Invalid operation %s", argv[1]); } return 0; }
void trace_syscall (struct process *process, const struct user_regs_struct *state1, const struct user_regs_struct *state2) { args_t args1; args_t args2; get_args (state1, &args1); get_args (state2, &args2); // http://www.skyfree.org/linux/kernel_network/socket.html switch (args1.nr) { #ifdef SYS_socketcall case SYS_socketcall: print_args_t (stderr, &args1); print_args_t (stderr, &args2); break; #else case SYS_socket: handle_socket (process, args2.ret, args1.a1, args1.a2, args1.a3); break; case SYS_sendto: handle_sendto (process, args2.ret, args1.a1, (const char *) args1.a2, args1.a3, args1.a4, (const struct sockaddr *) args1.a5, args1.a6); break; case SYS_recvfrom: handle_recvfrom (process, args2.ret, args1.a1, (const char *) args1.a2, args1.a3, args1.a4, (const struct sockaddr *) args1.a5, (const socklen_t *) args1.a6); break; case SYS_recvmsg: handle_recvmsg (process, args2.ret, args1.a1, (struct msghdr *) args1.a2, args1.a3); break; case SYS_sendmsg: handle_sendmsg (process, args2.ret, args1.a1, (const struct msghdr *) args1.a2, args1.a3); break; case SYS_recvmmsg: break; case SYS_sendmmsg: break; #endif case SYS_close: handle_close (process, args2.ret, args1.a1); break; case SYS_dup3: handle_dup3 (process, args2.ret, args1.a1, args1.a2, args1.a3); break; case SYS_dup2: handle_dup2 (process, args2.ret, args1.a1, args1.a2); break; case SYS_dup: handle_dup (process, args2.ret, args1.a1); break; /* case SYS_execve: case SYS_fork: case SYS_clone: pread64 preadv pwrite64 pwritev read readv recv sendfile (file -> socket) sendfile64 (file -> socket) splice (pipe -> socket), (socket->pipe) write writev */ } }
main(int argc, char **argv) { int i, pid, listenfd, socketfd; size_t length; static struct sockaddr_in proxy_addr; setenv("REQUEST_METHOD","GET",1); setenv("CONTENT_LENGTH","0",1); setenv("SCRIPT_NAME","/cgi/printenv.cgi",1); setenv("AUTH_TYPE","auth",1); setenv("REMOTE_USER","user",1); setenv("REMOTE_IDENT","ident",1); if(argc==1) printf("web server default port 11111\n"); int port; if(argc==2) port=(u_short)atoi(argv[1]); else port=11111; /* //背景繼續執行 child變成放牛吃草 要用kill PID殺掉 if(fork() != 0) return 0; */ /* 讓父行程不必等待子行程結束 */ signal(SIGCLD, SIG_IGN); /* 開啟網路 Socket */ if ((listenfd=socket(AF_INET, SOCK_STREAM,0))<0) exit(3); /* 網路連線設定 */ proxy_addr.sin_family = AF_INET; /* 使用任何在本機的對外 IP */ proxy_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* 使用 default or argv[1] Port */ proxy_addr.sin_port = htons(port); //讓結束之後不用等待 int optval = 1; setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval); /* 開啟網路監聽器 */ if (bind(listenfd, (struct sockaddr *)&proxy_addr,sizeof(proxy_addr))<0){ printf("Bind fail\n"); exit(3); } /* 開始監聽網路 */ if (listen(listenfd,64)<0) exit(3); char env_tem[100]; while(1) { length = sizeof(cli_addr); /* 等待客戶端連線 */ if ((socketfd = accept(listenfd, (struct sockaddr *)&cli_addr, (socklen_t*)&length))<0) exit(3); sprintf(env_tem,"%s",inet_ntoa(cli_addr.sin_addr)); setenv("REMOTE_ADDR",env_tem,1); setenv("REMOTE_HOST",env_tem,1); /* 分出子行程處理要求 */ if ((pid = fork()) < 0) { exit(3); } else { if (pid == 0) { /* 子行程 */ close(listenfd); handle_socket(socketfd); } else { /* 父行程 */ close(socketfd); } } } }
/* The main loop handles all connections and cleanup. * It returns if there are any problems with the listening socket. */ static void main_loop(void) { int optirun_socket_fd; struct clientsocket * first = 0; //pointer to the first socket struct clientsocket * last = 0; //pointer to the last socket struct clientsocket * curr = 0; //current pointer to a socket struct clientsocket * prev = 0; //previous pointer to a socket bb_log(LOG_INFO, "Started main loop\n"); /* Listen for Optirun conections and act accordingly */ while (bb_status.bb_socket != -1) { usleep(100000); //sleep 100ms to prevent 100% CPU time usage /* Accept a connection. */ optirun_socket_fd = socketAccept(&bb_status.bb_socket, SOCK_NOBLOCK); if (optirun_socket_fd >= 0) { bb_log(LOG_DEBUG, "Accepted new connection\n", optirun_socket_fd, bb_status.appcount); /* add to list of sockets */ curr = malloc(sizeof (struct clientsocket)); curr->sock = optirun_socket_fd; curr->inuse = 0; curr->next = 0; if (last == 0) { first = curr; last = curr; } else { last->next = curr; last = curr; } } /* loop through all connections, removing dead ones, receiving/sending data to the rest */ curr = first; prev = 0; while (curr != 0) { if (curr->sock < 0) { //remove from list if (curr->inuse > 0) { bb_status.appcount--; //stop X / card if there is no need to keep it running if ((bb_status.appcount == 0) && (bb_config.stop_on_exit)) { stop_secondary(); } } if (last == curr) { last = prev; } if (prev == 0) { first = curr->next; free(curr); curr = first; } else { prev->next = curr->next; free(curr); curr = prev->next; } } else { //active connection, handle it. handle_socket(curr); prev = curr; curr = curr->next; } } }//socket server loop /* loop through all connections, closing all of them */ curr = first; prev = 0; while (curr != 0) { //close socket if not already closed if (curr->sock >= 0) { socketClose(&curr->sock); } //remove from list if (curr->inuse > 0) { bb_status.appcount--; } if (last == curr) { last = prev; } if (prev == 0) { first = curr->next; free(curr); curr = first; } else { prev->next = curr->next; free(curr); curr = prev->next; } } }
static int DispatchCall( char *scriptname, int argc, char **argv ) { register int i, sd, len; int error_number; ssize_t readlen; struct sockaddr_un saun; struct stat stat_buf; struct stat sock_stat; char *sock_name; char buf[BUF_SIZE]; int respawn_script = 0; sd = 0; /* create socket name */ Dx(Debug("pperl: %s\n", scriptname)); sock_name = MakeSockName(scriptname); Dx(Debug("got socket: %s\n", sock_name)); if (!stat(sock_name, &sock_stat) && !stat(scriptname, &stat_buf)) { if (stat_buf.st_mtime >= sock_stat.st_mtime) { respawn_script = 1; Dx(Debug("respawning slave - top level script changed\n")); } } if (kill_script || respawn_script) { int pid_fd, sock_name_len; char *pid_file; pid_t pid = 0; respawn_script = 0; /* reset so we can use it later :-) */ sock_name_len = strlen(sock_name); pid_file = my_malloc(sock_name_len + 5); strncpy(pid_file, sock_name, sock_name_len); pid_file[sock_name_len] = '.'; pid_file[sock_name_len+1] = 'p'; pid_file[sock_name_len+2] = 'i'; pid_file[sock_name_len+3] = 'd'; pid_file[sock_name_len+4] = '\0'; Dx(Debug("opening pid_file: %s\n", pid_file)); pid_fd = open(pid_file, O_RDONLY); if (pid_fd == -1) { Dx(Debug("Cannot open pid file (perhaps PPerl wasn't running for that script?)\n")); write(1, "No process killed - no pid file\n", 32); goto killed; } readlen = read(pid_fd, buf, BUF_SIZE); if (readlen == -1) { perror("pperl: nothing in pid file?"); goto killed; } buf[readlen] = '\0'; close(pid_fd); pid = atoi(buf); Dx(Debug("got pid %d (%s)\n", pid, buf)); if (kill(pid, SIGINT) == -1) { if (errno == ESRCH) { perror("pperl kill"); Dx(Debug("Process didn't exist. Unlinking %s and %s\n", pid_file, sock_name)); unlink(pid_file); unlink(sock_name); } else { perror("pperl: could not kill process"); } } free(pid_file); killed: if (kill_script) { free(sock_name); /* Hmm, should probably do this everywhere else we return too */ return 0; } if (pid != 0) { /* cheesy - let the child go away proper */ while (!kill(pid, 0)) {} } } for (i = 0; i < 10; i++) { sd = socket(PF_UNIX, SOCK_STREAM, PF_UNSPEC); if (sd != -1) { break; } else if (NO_BUFSPC(errno)) { sleep(1); } else { perror("pperl: Couldn't create socket"); return 1; } } saun.sun_family = PF_UNIX; strcpy(saun.sun_path, sock_name); len = sizeof(saun.sun_family) + strlen(saun.sun_path) + 1; Dx(Debug("%d connecting\n", getpid())); if (stat((const char*)sock_name, &stat_buf)) { if (errno == ENOENT) { /* socket doesn't exist. good */ Dx(Debug("socket doesn't exist yet (good)\n")); } else { perror("Socket stat error"); exit(1); } } /* is there a race between stat() and connect() here? Or is it irrelevant? */ if (connect(sd, (struct sockaddr *)&saun, len) < 0) { /* Consider spawning Perl here and try again */ FILE *source; int tmp_fd; char temp_file[BUF_SIZE]; char *lock_file; int sock_name_len; int lock_fd; int start_checked = 0; int wrote_footer = 0; /* we may encounter __END__ or __DATA__ */ int line; int retry_connect = 0; int exit_code = 0; int pid, itmp, exitstatus; sigset_t mask, omask; Dx(Debug("Couldn't connect, spawning new server: %s\n", strerror(errno))); sock_name_len = strlen(sock_name); lock_file = my_malloc(sock_name_len + 6); strncpy(lock_file, sock_name, sock_name_len); lock_file[sock_name_len] = '.'; lock_file[sock_name_len+1] = 'l'; lock_file[sock_name_len+2] = 'o'; lock_file[sock_name_len+3] = 'c'; lock_file[sock_name_len+4] = 'k'; lock_file[sock_name_len+5] = '\0'; Dx(Debug("opening lock_file: %s\n", lock_file)); lock_fd = open(lock_file, O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR); if (lock_fd == -1) { perror("Cannot open lock file"); exit_code = 1; goto cleanup; } while (flock(lock_fd, LOCK_EX|LOCK_NB) == -1) { Dx(Debug("flock failed - someone else is probably waiting to spawn - sleeping\n")); retry_connect = 1; sleep(1); } if (retry_connect) { if (connect(sd, (struct sockaddr *)&saun, len) >= 0) { goto cleanup; /* everything is now OK! */ } /* otherwise we try ourselves to re-spawn */ } /* if (unlink(sock_name) != 0 && errno != ENOENT) { perror("pperl: removal of old socket failed"); exit_code = 1; goto cleanup; } */ /* Create temp file with adjusted script... */ if (!(source = fopen(scriptname, "r"))) { perror("pperl: Cannot open perl script"); exit_code = 1; goto cleanup; } snprintf(temp_file, BUF_SIZE, "%s/%s", P_tmpdir, "pperlXXXXXX"); tmp_fd = mkstemp(temp_file); if (tmp_fd == -1) { perror("pperl: Cannot create temporary file"); exit_code = 1; goto cleanup; } write(tmp_fd, "### Temp File ###\n", 18); write(tmp_fd, perl_header, strlen(perl_header)); /* rewrite the perl script with pperl.h.header contents wrapper and do some other fixups in the process */ line = 0; while ( fgets( buf, BUF_SIZE, source ) ) { readlen = strlen(buf); Dx(Debug("read '%s' %d \n", buf, readlen)); if (!start_checked) { /* first line */ start_checked = 1; if (buf[0] == '#' && buf[1] == '!') { char *args; /* solaris sometimes doesn't propogate all the * shebang line - so we do that here */ if ( (args = strstr(buf, " ")) ) { strncat(perl_options, args, strlen(args) - 1); } write(tmp_fd, "\n#line 2 ", 9); write(tmp_fd, scriptname, strlen(scriptname)); write(tmp_fd, "\n", 1); line = 2; continue; } else { write(tmp_fd, "\n#line 1 ", 9); write(tmp_fd, scriptname, strlen(scriptname)); write(tmp_fd, "\n", 1); } } if ((!strcmp(buf, "__END__\n") || !strcmp(buf, "__DATA__\n")) && !wrote_footer) { char text_line[BUF_SIZE]; wrote_footer = 1; write(tmp_fd, perl_footer, strlen(perl_footer)); snprintf(text_line, BUF_SIZE, "package main;\n#line %d %s\n", line, scriptname); write(tmp_fd, text_line, strlen(text_line)); } write(tmp_fd, buf, readlen); if (buf[readlen] == '\n') ++line; } if (fclose(source)) { perror("pperl: Error reading perl script"); exit_code = 1; goto cleanup; } if (!wrote_footer) write(tmp_fd, perl_footer, strlen(perl_footer)); Dx(Debug("wrote file %s\n", temp_file)); close(tmp_fd); /*** Temp file creation done ***/ snprintf(buf, BUF_SIZE, "%s %s %s %s %d %d %d %d %s", PERL_INTERP, perl_options, temp_file, sock_name, prefork, maxclients, any_user, no_cleanup, scriptname); Dx(Debug("syscall: %s\n", buf)); /* block SIGCHLD so noone else can wait() on the child before we do */ sigemptyset(&mask); sigaddset(&mask, SIGCHLD); sigprocmask(SIG_BLOCK, &mask, &omask); if ((pid = system(buf)) != 0) { unlink(temp_file); if (stat((const char*)sock_name, &stat_buf) == 0) { /* socket exists - perhaps we should just try and connect to it? */ /* possible cause is a race condition. So ignore this and just try the connect() call again. */ perror("pperl: perl script failed to start, but lets be gung-ho and try and connect again anyway!"); } perror("pperl: perl script failed to start"); exit_code = 1; goto cleanup; } else { Dx(Debug("waiting for perl to return...\n")); while ((itmp = waitpid(0, &exitstatus, 0)) == -1 && errno == EINTR) ; sigprocmask(SIG_SETMASK, &omask, NULL); Dx(Debug("returned.\n")); /* now remove the perl script */ unlink(temp_file); } /* try and connect to the new socket */ while ((i++ <= 30) && (connect(sd, (struct sockaddr *)&saun, len) < 0)) { Dx(Debug(".")); sleep(1); } if (i >= 30) { /* If we really *really* couldn't connect, try and delete the socket if it exists */ if (unlink(sock_name) != 0 && errno != ENOENT) { perror("pperl: removal of old socket failed"); } perror("pperl: persistent perl process failed to start after 30 seconds"); exit_code = 1; goto cleanup; } Dx(Debug("Connected\n")); cleanup: flock(lock_fd, LOCK_UN); close(lock_fd); free(lock_file); if (exit_code > 0) { free(sock_name); exit(exit_code); } } free(sock_name); return handle_socket(sd, argc, argv); }
int main (int argc, char *argv[]) { RIG *my_rig; /* handle to rig (instance) */ rig_model_t my_model = RIG_MODEL_DUMMY; int retcode; /* generic return code from functions */ int verbose = 0; int show_conf = 0; int dump_caps_opt = 0; const char *rig_file=NULL, *ptt_file=NULL, *dcd_file=NULL; ptt_type_t ptt_type = RIG_PTT_NONE; dcd_type_t dcd_type = RIG_DCD_NONE; int serial_rate = 0; char *civaddr = NULL; /* NULL means no need to set conf */ char conf_parms[MAXCONFLEN] = ""; struct addrinfo hints, *result, *saved_result; int sock_listen; int reuseaddr = 1; char host[NI_MAXHOST]; char serv[NI_MAXSERV]; while(1) { int c; int option_index = 0; c = getopt_long (argc, argv, SHORT_OPTIONS, long_options, &option_index); if (c == -1) break; switch(c) { case 'h': usage(); exit(0); case 'V': version(); exit(0); case 'm': if (!optarg) { usage(); /* wrong arg count */ exit(1); } my_model = atoi(optarg); break; case 'r': if (!optarg) { usage(); /* wrong arg count */ exit(1); } rig_file = optarg; break; case 'p': if (!optarg) { usage(); /* wrong arg count */ exit(1); } ptt_file = optarg; break; case 'd': if (!optarg) { usage(); /* wrong arg count */ exit(1); } dcd_file = optarg; break; case 'P': if (!optarg) { usage(); /* wrong arg count */ exit(1); } if (!strcmp(optarg, "RIG")) ptt_type = RIG_PTT_RIG; else if (!strcmp(optarg, "DTR")) ptt_type = RIG_PTT_SERIAL_DTR; else if (!strcmp(optarg, "RTS")) ptt_type = RIG_PTT_SERIAL_RTS; else if (!strcmp(optarg, "PARALLEL")) ptt_type = RIG_PTT_PARALLEL; else if (!strcmp(optarg, "CM108")) ptt_type = RIG_PTT_CM108; else if (!strcmp(optarg, "NONE")) ptt_type = RIG_PTT_NONE; else ptt_type = atoi(optarg); break; case 'D': if (!optarg) { usage(); /* wrong arg count */ exit(1); } if (!strcmp(optarg, "RIG")) dcd_type = RIG_DCD_RIG; else if (!strcmp(optarg, "DSR")) dcd_type = RIG_DCD_SERIAL_DSR; else if (!strcmp(optarg, "CTS")) dcd_type = RIG_DCD_SERIAL_CTS; else if (!strcmp(optarg, "CD")) dcd_type = RIG_DCD_SERIAL_CAR; else if (!strcmp(optarg, "PARALLEL")) dcd_type = RIG_DCD_PARALLEL; else if (!strcmp(optarg, "NONE")) dcd_type = RIG_DCD_NONE; else dcd_type = atoi(optarg); break; case 'c': if (!optarg) { usage(); /* wrong arg count */ exit(1); } civaddr = optarg; break; case 's': if (!optarg) { usage(); /* wrong arg count */ exit(1); } serial_rate = atoi(optarg); break; case 'C': if (!optarg) { usage(); /* wrong arg count */ exit(1); } if (*conf_parms != '\0') strcat(conf_parms, ","); strncat(conf_parms, optarg, MAXCONFLEN-strlen(conf_parms)); break; case 't': if (!optarg) { usage(); /* wrong arg count */ exit(1); } portno = optarg; break; case 'T': if (!optarg) { usage(); /* wrong arg count */ exit(1); } src_addr = optarg; break; case 'o': vfo_mode++; break; case 'v': verbose++; break; case 'L': show_conf++; break; case 'l': list_models(); exit(0); case 'u': dump_caps_opt++; break; default: usage(); /* unknown option? */ exit(1); } } rig_set_debug(verbose); rig_debug(RIG_DEBUG_VERBOSE, "rigctld, %s\n", hamlib_version); rig_debug(RIG_DEBUG_VERBOSE, "Report bugs to " "<*****@*****.**>\n\n"); my_rig = rig_init(my_model); if (!my_rig) { fprintf(stderr, "Unknown rig num %d, or initialization error.\n", my_model); fprintf(stderr, "Please check with --list option.\n"); exit(2); } retcode = set_conf(my_rig, conf_parms); if (retcode != RIG_OK) { fprintf(stderr, "Config parameter error: %s\n", rigerror(retcode)); exit(2); } if (rig_file) strncpy(my_rig->state.rigport.pathname, rig_file, FILPATHLEN - 1); /* * ex: RIG_PTT_PARALLEL and /dev/parport0 */ if (ptt_type != RIG_PTT_NONE) my_rig->state.pttport.type.ptt = ptt_type; if (dcd_type != RIG_DCD_NONE) my_rig->state.dcdport.type.dcd = dcd_type; if (ptt_file) strncpy(my_rig->state.pttport.pathname, ptt_file, FILPATHLEN - 1); if (dcd_file) strncpy(my_rig->state.dcdport.pathname, dcd_file, FILPATHLEN - 1); /* FIXME: bound checking and port type == serial */ if (serial_rate != 0) my_rig->state.rigport.parm.serial.rate = serial_rate; if (civaddr) rig_set_conf(my_rig, rig_token_lookup(my_rig, "civaddr"), civaddr); /* * print out conf parameters */ if (show_conf) { rig_token_foreach(my_rig, print_conf_list, (rig_ptr_t)my_rig); } /* * print out conf parameters, and exits immediately * We may be interested only in only caps, and rig_open may fail. */ if (dump_caps_opt) { dumpcaps(my_rig, stdout); rig_cleanup(my_rig); /* if you care about memory */ exit(0); } retcode = rig_open(my_rig); if (retcode != RIG_OK) { fprintf(stderr,"rig_open: error = %s \n", rigerror(retcode)); exit(2); } if (verbose > 0) printf("Opened rig model %d, '%s'\n", my_rig->caps->rig_model, my_rig->caps->model_name); rig_debug(RIG_DEBUG_VERBOSE, "Backend version: %s, Status: %s\n", my_rig->caps->version, rig_strstatus(my_rig->caps->status)); #ifdef __MINGW32__ # ifndef SO_OPENTYPE # define SO_OPENTYPE 0x7008 # endif # ifndef SO_SYNCHRONOUS_NONALERT # define SO_SYNCHRONOUS_NONALERT 0x20 # endif # ifndef INVALID_SOCKET # define INVALID_SOCKET -1 # endif WSADATA wsadata; if (WSAStartup(MAKEWORD(1,1), &wsadata) == SOCKET_ERROR) { fprintf(stderr,"WSAStartup socket error\n"); exit(1); } int sockopt = SO_SYNCHRONOUS_NONALERT; setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&sockopt, sizeof(sockopt)); #endif /* * Prepare listening socket */ memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */ hints.ai_socktype = SOCK_STREAM;/* TCP socket */ hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */ hints.ai_protocol = 0; /* Any protocol */ retcode = getaddrinfo(src_addr, portno, &hints, &result); if (retcode != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(retcode)); exit(2); } saved_result = result; do { sock_listen = socket(result->ai_family, result->ai_socktype, result->ai_protocol); if (sock_listen < 0) { handle_error (RIG_DEBUG_ERR, "socket"); freeaddrinfo(saved_result); /* No longer needed */ exit(2); } if (setsockopt(sock_listen, SOL_SOCKET, SO_REUSEADDR, (char *)&reuseaddr, sizeof(reuseaddr)) < 0) { handle_error (RIG_DEBUG_ERR, "setsockopt"); freeaddrinfo(saved_result); /* No longer needed */ exit (1); } #ifdef __MINGW32__ /* allow IPv4 mapped to IPv6 clients, MS default this to 1! */ sockopt = 0; if (setsockopt(sock_listen, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&sockopt, sizeof(sockopt)) < 0) { handle_error (RIG_DEBUG_ERR, "setsockopt"); freeaddrinfo(saved_result); /* No longer needed */ exit (1); } #endif if (0 == bind(sock_listen, result->ai_addr, result->ai_addrlen)) { break; } handle_error (RIG_DEBUG_WARN, "binding failed (trying next interface)"); #ifdef __MINGW32__ closesocket (sock_listen); #else close (sock_listen); #endif } while ((result = result->ai_next) != NULL); freeaddrinfo(saved_result); /* No longer needed */ if (NULL == result) { rig_debug(RIG_DEBUG_ERR, "bind error - no available interface\n"); exit (1); } if (listen(sock_listen, 4) < 0) { handle_error (RIG_DEBUG_ERR, "listening"); exit (1); } /* * main loop accepting connections */ do { #ifdef HAVE_PTHREAD pthread_t thread; pthread_attr_t attr; #endif struct handle_data *arg; arg = malloc(sizeof(struct handle_data)); if (!arg) { rig_debug(RIG_DEBUG_ERR, "malloc: %s\n", strerror(errno)); exit (1); } arg->rig = my_rig; arg->clilen = sizeof (arg->cli_addr); arg->sock = accept(sock_listen, (struct sockaddr *)&arg->cli_addr, &arg->clilen); if (arg->sock < 0) { handle_error (RIG_DEBUG_ERR, "accept"); break; } if ((retcode = getnameinfo ((struct sockaddr const *)&arg->cli_addr, arg->clilen, host, sizeof (host) , serv, sizeof (serv), NI_NOFQDN)) < 0) { rig_debug (RIG_DEBUG_WARN, "Peer lookup error: %s", gai_strerror (retcode)); } rig_debug(RIG_DEBUG_VERBOSE, "Connection opened from %s:%s\n", host, serv); #ifdef HAVE_PTHREAD pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); retcode = pthread_create(&thread, &attr, handle_socket, arg); if (retcode != 0) { rig_debug(RIG_DEBUG_ERR, "pthread_create: %s\n", strerror(retcode)); break; } #else handle_socket(arg); #endif } while (retcode == 0); rig_close(my_rig); /* close port */ rig_cleanup(my_rig); /* if you care about memory */ #ifdef __MINGW32__ WSACleanup(); #endif return 0; }
int main(int argc, char **argv) { if (argc != 4) print_help("Wrong number of arguments"); struct sockaddr_in serv_addr; int sockfd = 0; char buf[1024]; char cmd[1024]; char ip[32]; int n, k; if (get_ip_by_hostname(ip, argv[3]) != 0) { perror("Error by getting ip"); print_help("Bad server"); } if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror("Can't create socket"); return -1; } memset(&serv_addr, 0, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(PORT); if(inet_pton(AF_INET, ip, &serv_addr.sin_addr) <= 0) { perror("Inet_Pton error"); return -1; } if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { perror("Connect error"); return -1; } //wrte(sockfd, "\n", 1); int state = 0; char *token; while ((n = read(sockfd, buf, sizeof(buf))) > 0) { if (strstr(buf, "+OK") != NULL) { state++; } else{ if (state == 1) { print_help("Bad username or password"); } if (state == 2) { print_help("Bad username or password"); } } if (state == 1) { write(sockfd, "USER ", 5); write(sockfd, argv[1], strlen(argv[1])); write(sockfd, "\n", 1); //Write password continue; } if (state == 2){ write(sockfd, "PASS ",5); write(sockfd, argv[2], strlen(argv[2])); write(sockfd, "\n", 1); continue; } if (state == 3) break; } printf("Success login\n\t<list> - to print list\n\t<msg> <n> - get <n>th message\n\t<exit> - exit\n"); while ((k = read(0, cmd, sizeof(cmd))) > 0) { if (strstr(cmd, "list") != NULL) { print_list(sockfd); handle_socket(sockfd); } else if (strstr(cmd, "msg") != NULL) { token = strtok(cmd, " \t"); char* msg = strtok(NULL," \t"); print_mail(sockfd, msg); handle_socket(sockfd); } else if (strstr(cmd, "exit") != NULL) { disconnect(sockfd); break; } } close(sockfd); }
int main(int argc, char *argv[]) { #ifdef _WIN32 HANDLE thread; #else pthread_t tid; #endif char *server_ip = DEFAULT_SERVER_IP; char *port_str = DEFAULT_PORT; char *filename = DEFAULT_FILE; int err = 0; int sockfd = 0; int c = 0; while ((c = getopt(argc, argv, "ls:p:")) != -1) { switch (c) { case 's': server_ip = optarg; break; case 'p': port_str = optarg; break; case 'l': g_libpcap_mode = 1; break; case ':': /* -f or -o without operand */ fprintf(stderr, "Option -%c requires an operand\n", optopt); err++; break; case '?': fprintf(stderr, "Unrecognized option: '-%c'\n", optopt); err++; } } for ( ; optind < argc; optind++) { if (filename != DEFAULT_FILE) err++; filename = argv[optind]; break; } if (err) usage(argv); sockfd = initialise_common(server_ip, port_str); g_pcap_fptr = fopen(filename, "wb"); if (g_libpcap_mode) { // Emit libpcap common header emit_pcap_header(g_pcap_fptr); } else { // Emit common header and two interface descriptions as there are two on the tap emit_pcapng_section_header_block(g_pcap_fptr); emit_pcapng_interface_description_block(g_pcap_fptr); emit_pcapng_interface_description_block(g_pcap_fptr); } fflush(g_pcap_fptr); // Now start the console #ifdef _WIN32 thread = CreateThread(NULL, 0, console_thread, &sockfd, 0, NULL); if (thread == NULL) print_and_exit("ERROR: Failed to create console thread\n"); #else err = pthread_create(&tid, NULL, &console_thread, &sockfd); if (err != 0) print_and_exit("ERROR: Failed to create console thread\n"); #endif handle_socket(sockfd); return 0; }
int main (int argc, char *argv[]) { ROT *my_rot; /* handle to rot (instance) */ rot_model_t my_model = ROT_MODEL_DUMMY; int retcode; /* generic return code from functions */ int verbose = 0; int show_conf = 0; int dump_caps_opt = 0; const char *rot_file=NULL; int serial_rate = 0; char conf_parms[MAXCONFLEN] = ""; struct addrinfo hints, *result; int sock_listen; int reuseaddr = 1; while(1) { int c; int option_index = 0; c = getopt_long (argc, argv, SHORT_OPTIONS, long_options, &option_index); if (c == -1) break; switch(c) { case 'h': usage(); exit(0); case 'V': version(); exit(0); case 'm': if (!optarg) { usage(); /* wrong arg count */ exit(1); } my_model = atoi(optarg); break; case 'r': if (!optarg) { usage(); /* wrong arg count */ exit(1); } rot_file = optarg; break; case 's': if (!optarg) { usage(); /* wrong arg count */ exit(1); } serial_rate = atoi(optarg); break; case 'C': if (!optarg) { usage(); /* wrong arg count */ exit(1); } if (*conf_parms != '\0') strcat(conf_parms, ","); strncat(conf_parms, optarg, MAXCONFLEN-strlen(conf_parms)); break; case 't': if (!optarg) { usage(); /* wrong arg count */ exit(1); } portno = optarg; break; case 'T': if (!optarg) { usage(); /* wrong arg count */ exit(1); } src_addr = optarg; break; case 'v': verbose++; break; case 'L': show_conf++; break; case 'l': list_models(); exit(0); case 'u': dump_caps_opt++; break; default: usage(); /* unknown option? */ exit(1); } } rig_set_debug(verbose); rig_debug(RIG_DEBUG_VERBOSE, "rotctld, %s\n", hamlib_version); rig_debug(RIG_DEBUG_VERBOSE, "Report bugs to " "<*****@*****.**>\n\n"); my_rot = rot_init(my_model); if (!my_rot) { fprintf(stderr, "Unknown rot num %d, or initialization error.\n", my_model); fprintf(stderr, "Please check with --list option.\n"); exit(2); } retcode = set_conf(my_rot, conf_parms); if (retcode != RIG_OK) { fprintf(stderr, "Config parameter error: %s\n", rigerror(retcode)); exit(2); } if (rot_file) strncpy(my_rot->state.rotport.pathname, rot_file, FILPATHLEN - 1); /* FIXME: bound checking and port type == serial */ if (serial_rate != 0) my_rot->state.rotport.parm.serial.rate = serial_rate; /* * print out conf parameters */ if (show_conf) { rot_token_foreach(my_rot, print_conf_list, (rig_ptr_t)my_rot); } /* * print out conf parameters, and exits immediately * We may be interested only in only caps, and rig_open may fail. */ if (dump_caps_opt) { dumpcaps_rot(my_rot, stdout); rot_cleanup(my_rot); /* if you care about memory */ exit(0); } retcode = rot_open(my_rot); if (retcode != RIG_OK) { fprintf(stderr,"rot_open: error = %s \n", rigerror(retcode)); exit(2); } if (verbose > 0) printf("Opened rot model %d, '%s'\n", my_rot->caps->rot_model, my_rot->caps->model_name); rig_debug(RIG_DEBUG_VERBOSE, "Backend version: %s, Status: %s\n", my_rot->caps->version, rig_strstatus(my_rot->caps->status)); #ifdef __MINGW32__ # ifndef SO_OPENTYPE # define SO_OPENTYPE 0x7008 # endif # ifndef SO_SYNCHRONOUS_NONALERT # define SO_SYNCHRONOUS_NONALERT 0x20 # endif # ifndef INVALID_SOCKET # define INVALID_SOCKET -1 # endif WSADATA wsadata; if (WSAStartup(MAKEWORD(1,1), &wsadata) == SOCKET_ERROR) { fprintf(stderr,"WSAStartup socket error\n"); exit(1); } int sockopt = SO_SYNCHRONOUS_NONALERT; setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&sockopt, sizeof(sockopt)); #endif /* * Prepare listening socket */ memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */ hints.ai_socktype = SOCK_STREAM;/* TCP socket */ hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */ hints.ai_protocol = 0; /* Any protocol */ retcode = getaddrinfo(src_addr, portno, &hints, &result); if (retcode != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(retcode)); exit(2); } sock_listen = socket(result->ai_family, result->ai_socktype, result->ai_protocol); if (sock_listen < 0) { perror("ERROR opening socket"); exit(1); } if (setsockopt(sock_listen, SOL_SOCKET, SO_REUSEADDR, (char *)&reuseaddr,sizeof(reuseaddr)) < 0) { rig_debug(RIG_DEBUG_ERR, "setsockopt: %s\n", strerror(errno)); exit (1); } if (bind(sock_listen, result->ai_addr, result->ai_addrlen) < 0) { rig_debug(RIG_DEBUG_ERR, "binding: %s\n", strerror(errno)); exit (1); } freeaddrinfo(result); /* No longer needed */ if (listen(sock_listen,4) < 0) { rig_debug(RIG_DEBUG_ERR, "listening: %s\n", strerror(errno)); exit (1); } /* * main loop accepting connections */ do { #ifdef HAVE_PTHREAD pthread_t thread; pthread_attr_t attr; #endif struct handle_data *arg; arg = malloc(sizeof(struct handle_data)); if (!arg) { rig_debug(RIG_DEBUG_ERR, "malloc: %s\n", strerror(errno)); exit (1); } arg->rot = my_rot; arg->clilen = sizeof(arg->cli_addr); arg->sock = accept(sock_listen, (struct sockaddr *) &arg->cli_addr, &arg->clilen); if (arg->sock < 0) { rig_debug(RIG_DEBUG_ERR, "accept: %s\n", strerror(errno)); break; } rig_debug(RIG_DEBUG_VERBOSE, "Connection opened from %s:%d\n", inet_ntoa(arg->cli_addr.sin_addr), ntohs(arg->cli_addr.sin_port)); #ifdef HAVE_PTHREAD pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); retcode = pthread_create(&thread, &attr, handle_socket, arg); if (retcode != 0) { rig_debug(RIG_DEBUG_ERR, "pthread_create: %s\n", strerror(retcode)); break; } #else handle_socket(arg); #endif } while (retcode == 0); rot_close(my_rot); /* close port */ rot_cleanup(my_rot); /* if you care about memory */ #ifdef __MINGW32__ WSACleanup(); #endif return 0; }