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;
}
