int main(int argc, char *argv[])
{
FILE *fh = NULL;
if (argc != 2) {
fprintf(stderr, "Please specify file to write to.\n");
return EXIT_FAILURE;
}
if (argc == 2) {
fh = fopen(argv[1], "w");
if (NULL == fh) {
fprintf(stderr, "Failure to open file.\n");
return EXIT_FAILURE;
}
}
int sock = client_init("225.1.1.1", 5555);
struct sample samples[SAMPLES_PER_FILE];
memset(samples, 0, sizeof(samples));
struct sample *cap = samples;
while (true) {
size_t len = client_recv(sock, (uint8_t *)cap,
SAMPLES_PER_CAPTURE * sizeof(*cap));
assert(SAMPLES_PER_CAPTURE * sizeof(*cap) == len);
cap += SAMPLES_PER_CAPTURE;
if (cap >= &samples[SAMPLES_PER_FILE]) {
// Write out the file with all the known samples.
fh = fopen(argv[1], "w");
for (int i = 0; i < ARRAY_LEN(samples); i++) {
fprintf(fh, "%f %03.4f\n", samples[i].t.tv_sec +
samples[i].t.tv_nsec / NSEC_PER_SEC,
((105.84 / 4096) * samples[i].d) / 0.1);
}
fclose(fh);
// Shift room for the new samples.
memset(samples, 0, sizeof(samples));
cap = samples;
}
}
return EXIT_SUCCESS;
}
void
win_server_main_loop (WinServer *server)
{
while (!server->stop) {
fd_set readfds;
int ret;
Client *client;
struct timeval tv;
struct sockaddr_in addr;
int addr_len;
SOCKET sock;
/* Check whether there are incoming connections. */
tv.tv_sec = 0;
tv.tv_usec = 50000;
FD_ZERO (&readfds);
FD_SET (server->sock, &readfds);
ret = select (0, &readfds, NULL, NULL, &tv);
if (ret == SOCKET_ERROR) {
/* Error. */
return;
} else if (ret == 0)
/* No incoming connections. */
continue;
/* Accept incoming connection. */
addr_len = sizeof (addr);
sock = accept (server->sock, (struct sockaddr *) &addr, &addr_len);
if (sock == INVALID_SOCKET) {
/* Failed. */
return;
}
/* Create a Client structure and pass it to the callback. */
client = malloc (sizeof (Client));
client->fd = sock;
client_init (client);
server->callback (client);
}
}
/* ----------------------------------------------------------------------------*/
int main(int argc,char* argv[]) {
int i;
char directory[1024];
strcpy(soundCardName,"HPSDR");
strcpy(server_address,"127.0.0.1"); // localhost
processCommands(argc,argv);
fprintf(stderr,"gHPSDR rx %d (Version %s)\n",receiver,VERSION);
setSoundcard(getSoundcardId(soundCardName));
// initialize DttSP
if(getcwd(directory, sizeof(directory))==NULL) {
fprintf(stderr,"current working directory path is > 1024 bytes!");
exit(1);
}
Setup_SDR(directory);
Release_Update();
SetTRX(0,0); // thread 0 is for receive
SetTRX(1,1); // thread 1 is for transmit
SetRingBufferOffset(0,offset);
SetThreadProcessingMode(0,2);
SetThreadProcessingMode(1,2);
SetSubRXSt(0,0,1);
SetRXOutputGain(0,0,0.20);
reset_for_buflen(0,1024);
reset_for_buflen(1,1024);
client_init(receiver);
audio_stream_init(receiver);
// initialize ozy
ozy_init();
while(1) {
sleep(10000);
}
return 0;
}
int main(int ac, char **av)
{
t_client *clt;
if ((clt = malloc(sizeof(t_client))) == NULL)
return (err_msg(": malloc fail"));
if (ac != 3)
{
printf("Usage: ./client <ip server> <port nb>\n");
return (-1);
}
if (client_init(clt, av) == -1)
return (-1);
if (client_loop(clt) == -1)
return (-1);
close(clt->fd);
free(clt->line);
free(clt->srv_ret);
return (1);
}
int main () {
request_t request;
response_t response;
request.client_id = 1;
request.priority = 1;
request.client_seq_id = 1;
int sd = client_init ("localhost", 5050);
send_request_t(sd, &request);
read_response_t(sd,&response);
printf("The worker id is %d\n",response.worker_id);
return 0;
}
void init_client(int s, t_env *e, t_client client)
{
int father;
t_play player;
father = fork();
if (father > 0)
return ;
if (father == 0)
{
if ((s = client_init(client.port, client.host)) < 0)
{
ft_putendl_fd("Client init error\n", 2);
exit(0);
}
printf("SON\n");
player = init_play(s, client);
ft_loop(s, e, player);
}
}
int
main(int argc, char* argv[])
{
CORBA_char filename[] = "/tmp/test-atspi.ior";
Accessibility_Role data;
int i;
struct timeval start, end;
long d_secs;
long d_usec;
Accessibility_Accessible service = CORBA_OBJECT_NIL;
CORBA_Environment ev[1];
CORBA_exception_init(ev);
client_init (&argc, argv, &global_orb, ev);
etk_abort_if_exception(ev, "init failed");
g_print ("Reading service reference from file \"%s\"\n", filename);
service = (Accessibility_Accessible) etk_import_object_from_file (global_orb,
filename,
ev);
etk_abort_if_exception(ev, "import service failed");
gettimeofday(&start, NULL);
for (i=0; i<NUM_CALLS; i++)
{
data = Accessibility_Accessible_getRole(service, ev);
}
gettimeofday(&end, NULL);
d_secs = end.tv_sec - start.tv_sec;
d_usec = end.tv_usec - start.tv_usec;
printf("\nGetRole : %f\n", (float) d_secs + ((float) d_usec / 1000000.0));
client_cleanup (global_orb, service, ev);
etk_abort_if_exception(ev, "cleanup failed");
exit (0);
}
static void
testing_init()
{
#ifdef STATIC_ALLOC_LINKEDLIST_NODES
printf("Only static memory to be used for linkedlist nodes.\n");
linkedlist_init();
printf("\n");
#else
printf("Linkedlist nodes will be created with heap memory.\n");
#endif
#ifdef STATIC_ALLOC_CLIENTS
printf("Only static memory to be used for client structures.\n");
client_init();
printf("\n");
#else
printf("Client structures will be created with heap memory.\n");
#endif
world_init();
}
void server_event_accept(struct evconnlistener *listener,
evutil_socket_t c_socket,
struct sockaddr *c_addr,
int socklen, void *arg)
{
log_info("Connected client socket:%d, from:%s:%d", c_socket,
inet_ntoa(((struct sockaddr_in*)c_addr)->sin_addr),
ntohs(((struct sockaddr_in*)c_addr)->sin_port));
server_t *s= (server_t*) arg;
if(setting_get_max_connections(s->setting) <= server_get_current_connections(s->worker_list, s->worker_count))
{
log_warn("Reached to max connection(%" PRIu64 ")", s->conn_cur_count);
resp_error_max_connection(s->msg_buf, c_socket);
close(c_socket);
return;
}
// debug용
if(s->conn_cur_count > s->conn_max)
{
s->conn_max = s->conn_cur_count;
}
worker_t *w = server_get_least_connection_worker(s->worker_list, s->worker_count);
client_t *c = client_init(w, c_socket, (struct sockaddr_in*)c_addr);
c->worker = w;
c->bufevent = worker_add_new_connection(w, c_socket);
c->evbuf = evbuffer_new();
bufferevent_setcb(c->bufevent, client_event_read, client_event_write, client_event_error, c);
bufferevent_enable(c->bufevent, EV_READ);
log_info("Accepted client connection. socket #%d from %s:%d", c_socket, inet_ntoa(c->addr.sin_addr), ntohs(c->addr.sin_port));
log_info("Connected clients : %"PRIu64"", server_get_current_connections(s->worker_list, s->worker_count));
return;
}
int main(int argc,char *argv[])
{
int choice = 0;
do {
printf("1.Server\n2.Client\nEnter Choice or press 0(ZERO) to exit:");
scanf("%d",&choice);
switch(choice)
{
case 1:
if ( 0 != server_init())
printf("Failed to init Server\n");
break;
case 2:
client_init();
break;
default:
printf("Byeeee \n");
exit(0);
}
}while(1);
}
void client_new(int fd, const struct sockaddr *sa, size_t sa_length, int uid)
{
struct client *client;
char *remote;
if (num_clients >= client_max_connections) {
g_warning("Max Connections Reached!");
close(fd);
return;
}
client = g_new0(struct client, 1);
clients = g_list_prepend(clients, client);
++num_clients;
client_init(client, fd);
client->uid = uid;
remote = sockaddr_to_string(sa, sa_length, NULL);
g_log(G_LOG_DOMAIN, LOG_LEVEL_SECURE,
"[%u] opened from %s", client->num, remote);
g_free(remote);
}
int EPLIB_init()
{
process_env_vars();
init_sig_handlers();
PMPI_Comm_rank(MPI_COMM_WORLD, &taskid);
PMPI_Comm_size(MPI_COMM_WORLD, &num_tasks);
set_local_uuid(taskid);
allocator_init();
if (max_ep == 0) return MPI_SUCCESS;
/* Initialize client */
client_init(taskid, num_tasks);
/* Register MPI type and MPI Op before any other cqueue commands */
cqueue_mpi_type_register();
cqueue_mpi_op_register();
/* Initialize communicator handles table */
handle_init();
/* Initialize window object table */
window_init();
/* Create server world and peer comm for MPI_COMM_WORLD */
EPLIB_split_comm(MPI_COMM_WORLD, 0, taskid, MPI_COMM_WORLD);
if (std_mpi_mode == STD_MPI_MODE_IMPLICIT)
block_coll_request = malloc(max_ep*sizeof(MPI_Request));
return MPI_SUCCESS;
}
int
main (int argc, char **argv)
{
int retval;
char * remotehost = DEFAULT_REMOTEHOST, * port = DEFAULT_PORT;
while ((retval = getopt(argc, argv, "dn:hH:P:")) != -1) {
switch (retval) {
case 'H':
remotehost = optarg;
break;
case 'P':
port = optarg;
break;
case 'd':
debug = 1;
break;
case 'h':
usage(argv[0], EXIT_SUCCESS);
break;
default:
break;
}
}
if (argc > optind) /* || !hostname || !port)*/
usage(argv[0], EXIT_FAILURE);
signal(SIGPIPE, SIG_IGN);
if(client_init(remotehost, port))
printf_die(stderr, "could not connect to : %s:%s\n", EXIT_FAILURE, remotehost, port);
srandom(time(NULL) + getpid());
srand(time(NULL) + getpid());
rmain ();
}
int init(void){
device = alcOpenDevice(NULL);
if(device) {
context = alcCreateContext(device, NULL);
}
alcMakeContextCurrent(context);
if (enet_initialize () != 0)
{
fprintf (stderr, "An error occurred while initializing ENet.\n");
return EXIT_FAILURE;
}
atexit (enet_deinitialize);
atexit (alCleanUp);
atexit (clean_up);
enet_client = enet_host_create (NULL /* create a client host */,
1 /* only allow 1 outgoing connection */,
0 /* allow up 4 channels to be used, 0 and 1 */,
0 /* 56K modem with 56 Kbps downstream bandwidth */,
0 /* 56K modem with 14 Kbps upstream bandwidth */);
if (enet_client == NULL)
{
fprintf (stderr,
"An error occurred while trying to create an ENet client host.\n");
exit (EXIT_FAILURE);
}
tclient = client_init(enet_client);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
}
int main(int argc, const char** argv)
{
struct client cli;
// Set default hostname.
strcpy(cli.host, DEFAULT_HOST);
// Set def. port & time.
cli.port = DEFAULT_PORT;
cli.time = DEFAULT_TIME;
// Process user arguments.
process_args(&cli, argv, argc);
printf("Connecting to %s:%d\n", cli.host, cli.port);
if (client_init(&cli, cli.host, cli.port) == -1) {
return EXIT_FAILURE;
}
client_start(&cli);
client_stop(&cli);
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
serverstate_set_event_loop(uv_default_loop());
config_init();
listener_init();
client_init();
module_init();
server_init();
command_init();
connection_init();
process_commandline(argv, argc);
config_load();
listener_start_listeners();
module_load_all_modules();
connection_init_tls();
uv_run(serverstate_get_event_loop(), UV_RUN_DEFAULT);
return 0;
}
int
main (int argc, char *argv[])
{
ChannelCallbacks callbacks;
g_type_init ();
gui_init (&argc, &argv);
client_init ();
callbacks.input = input_cb;
callbacks.disconnect = disconnect_cb;
callbacks.error = error_cb;
callbacks.user_data = NULL;
chn_set_callbacks (&callbacks);
if (g_strcmp0 (getenv ("ntx_channel"), "echo") == 0)
chn_echo_init ();
else if (g_strcmp0 (getenv ("ntx_channel"), "pty") == 0)
chn_pty_init (argc > 1 ? argv[1] : "/bin/sh");
else
chn_telnet_init (argc > 1 ? argv[1] : "localhost", argc > 2 ? atoi (argv[2]) : 23);
chn_connect ();
gtk_main ();
chn_disconnect ();
chn_finalize ();
client_deinit ();
return 0;
}
int main(int argc, const char *argv[])
{
#define OPEN 1
#define CLOSE 0
pthread_t show_data,wait_controller;
int err,ret,alive;
FD_ZERO(&wset);
FD_ZERO(&rset);
FD_SET(fd,&wset);
FD_SET(fd,&rset);
ss = fx_serial_start();
fd = client_init(7000,argv[1]);
select(fd+1,&rset,&wset,NULL,NULL);
restart:
/*set keepalive on fd*/
alive = 1;
if(setsockopt(fd,SOL_SOCKET,SO_KEEPALIVE,&alive,sizeof(alive)) != 0)
{
fprintf(stderr,"set socket option error\n");
goto restart;
}
socket_set_keepalive(fd);
ret = connect_retry(fd,(struct sockaddr *)&clientaddr,sizeof(clientaddr));
if(ret == -1)
{
printf("cannot connect to server\n");
exit(1);
}
signal(SIGINT,free_space);
err = pthread_create(&wait_controller,NULL,Control_controller,NULL);
if(err != 0)
{
fprintf(stderr,"cannot create the thread\n");
exit(1);
}
while(1)
{
header__init(&MS.mh);
sensor_info__init(&MS.si);
sensor_t__init(&MS.st);
Get_data();
//test();
sleep(293); //sleep 5 mins
}
//err = pthread_create(&show_data,NULL,Sensor_data,NULL);
//if(err != 0)
// {
// fprintf(stderr,"cannot create the thread\n");
// exit(1);
//}
//pthread_join(show_data, NULL);
pthread_join(wait_controller, NULL);
//while(1) getchar();
return 0;
}
int main(int argc, char *argv[])
{
/*初始化*/
int sock_fd, n;
struct sockaddr_in r_addr, srv_addr;
socklen_t addr_len = sizeof(r_addr);
CHK_RET_EXIT(sock_fd, client_init(argc, argv));
char buf[MAX_PACK_SIZE] = {0};
bzero(&srv_addr, sizeof(srv_addr));
srv_addr.sin_family = AF_INET;
inet_pton(AF_INET, DEFAULT_SERVER_IP, &srv_addr.sin_addr);
/*拉去频道列表，选择频道号*/
bzero(&r_addr, addr_len);
while (1) {
/*收包*/
n = recvfrom(sock_fd, buf, sizeof(buf) - 1, 0,
(struct sockaddr *)&r_addr, &addr_len);
if (n < 0) {
if (errno == EINTR || errno == EAGAIN) {
continue;
}
perror("recvfrom");
break;
}
//DEBUG("buf:%s\n", buf);
#if 1
struct chnlist_info_st *plist = (struct chnlist_info_st *)buf;
if (plist->chn_id == LIST_CHN_ID) {
/*展示频道信息*/
DEBUG("recv:chnlist_info package,(%d)\n", n);
show_chn_list(plist, n);
break;
}
#endif
}
/*选择频道号*/
int chose_id = 2;
#if 1
printf("chose_id:");
fflush(stdout);
n = scanf("%d", &chose_id);
if (n != 1) {
perror("scanf");
exit(1);
}
#endif
printf("your chose chanel:%d\n", chose_id);
int pipe_fd[2];
pipe(pipe_fd);
pid_t pid = fork();
if (pid == 0) {
close(pipe_fd[1]);
dup2(pipe_fd[0], STDIN_FILENO);
close(pipe_fd[0]);
execlp("mpg123", "mpg123", "-q", "-", NULL);
exit(0);
}
/*收到指定频道数据*/
while (1) {
/*收包*/
n = recvfrom(sock_fd, buf, sizeof(buf) - 1, 0,
(struct sockaddr *)&r_addr, &addr_len);
if (n < 0) {
if (errno == EINTR || errno == EAGAIN) {
continue;
}
perror("recvfrom");
break;
}
struct mesg_info_st *pmesg = (struct mesg_info_st *)buf;
/*判断是否为指定ID的消息*/
if (pmesg->chn_id != chose_id) {
continue;
}
// DEBUG("chn_id:%d\n", pmesg->chn_id);
#if 0
/*判断是否从服务器中发出的消息*/
if (r_addr.sin_addr.s_addr != srv_addr.sin_addr.s_addr) {
fprintf(stderr,"收到非发主机的组播信息,from '%s:%hu'\n", inet_ntoa(r_addr.sin_addr), ntohs(r_addr.sin_port));
continue;
}
#endif
// DEBUG("(%d)%s\n", n, (char *)(pmesg->data));
#if 1
close(pipe_fd[0]);
dup2(pipe_fd[1], STDOUT_FILENO);
write(STDOUT_FILENO, pmesg->data, n - 1);
/*关闭*/
#endif
}
wait(NULL);
return 0;
}
main(int argc, char *argv[ ])
{
//*Lab 5 CODE
char *tok;
char cmdArgs[2][MAX] = {'\0'};
char cwd[128];
int cmdCount = 0;
//LAB 5 CODE*
char temp[MAX];
int n;
char line[MAX], ans[MAX];
//*Lab 5 CODE
getcwd(cwd, 128); // get CWD pathname
// Lab 5 CODE*
printf("cwd: %s\n", cwd);
if (argc < 3){
printf("Usage : client ServerName ServerPort\n");
exit(1);
}
client_init(argv);
// sock <---> server
printf("******** processing loop *********\n");
while (1){
//printf("input two numbers to add : ");
//bzero(line, MAX); // zero out line[ ]
// *LAB 5 CODE
cmdCount = 0;
strcpy(cmdArgs[0],"");
strcpy(cmdArgs[1],"");
printf("Input a command: ");
// LAB 5 CODE*
fgets(line, MAX, stdin); // get a line (end with \n) from stdin
//printf("line: %s\n", line);
line[strlen(line)-1] = 0; // kill \n at end
//printf("line[0]: %c\n", line[0]);
//if(line[0]==0) // exit if NULL line
//{exit(0);}
// *Lab 5 CODE
strcpy(temp, line);
//printf("temp: %s\n", temp);
tok = strtok(line, " ");
cmdCount++;
//printf("temp: %s\n", temp);
//printf("cmdArgs[0] = %s\n", cmdArgs[0]);
//printf("cmdCount: %d\n", cmdCount);
while(tok != NULL)
{
strcpy(cmdArgs[cmdCount-1], tok);
tok = strtok(NULL, " ");
cmdCount++;
//printf("cmdCount: %d\n", cmdCount);
}
//printf("cmdCount: %d\n", cmdCount);
//printf("line: %s\n", line);
//printf("cmdArgs[0] = %s\n", cmdArgs[0]);
if(strcmp(cmdArgs[0], "lcat") == 0)
{
if(strcmp(cmdArgs[1],"") != 0) {mycat(cmdArgs[1]);}
else {printf("ERROR: pathname not given");}
}
else if (strcmp(cmdArgs[0], "lpwd") == 0)
{
mypwd(cwd);
}
else if (strcmp(cmdArgs[0], "lls") == 0)
{
printf("args: %s\n", cmdArgs[1]);
if(strcmp(cmdArgs[1],"") != 0) {myls(cmdArgs[1]);}
else
{
printf("cwd: %s\n", cwd);
myls(cwd);
}
}
else if (strcmp(cmdArgs[0], "lcd") == 0)
{
if(strcmp(cmdArgs[1],"") != 0) {mycd(cmdArgs[1]);}
else {mycd(cwd);}
}
else if (strcmp(cmdArgs[0], "lmkdir") == 0)
{
if(strcmp(cmdArgs[1],"") != 0) {mymkdir(cmdArgs[1]);}
else {printf("ERROR: pathname not given");}
}
else if (strcmp(cmdArgs[0], "lrmdir") == 0)
{
if(strcmp(cmdArgs[1],"") != 0) {myrmdir(cmdArgs[1]);}
else {printf("ERROR: pathname not given");}
}
else if (strcmp(cmdArgs[0], "lrm") == 0)
{
if(strcmp(cmdArgs[1],"") != 0) {myrm(cmdArgs[1]);}
else {printf("ERROR: pathname not given");}
}
else if (strcmp(cmdArgs[0], "get") == 0)
{
if(strcmp(cmdArgs[1],"") != 0) {mycp(cmdArgs[1], cwd);}
else {printf("ERROR: pathname not given");}
}
else if (strcmp(cmdArgs[0], "quit") == 0)
{
printf("Goodbye!\n");
return 0;
}
else // Not a local command, work with the sever
{
// Send command to server
n = write(server_sock, temp, MAX);
printf("client: wrote n=%d bytes; line=(%s)\n", n, temp);
// Send command pathname
//n = write(server_sock, cmdArgs[0], MAX);
//printf("client: wrote n=%d bytes; line=(%s)\n", n, line);
// Now read the Reply and Results in from the Server...
//REPLY
//n = read(server_sock, ans, MAX);
//printf("client: read n=%d bytes; echo=(%s)\n",n, ans);
//RESULTS
//n = read(server_sock, ans, MAX);
//printf("client: read n=%d bytes; echo=(%s)\n",n, ans);
readData(ans);
}
// Lab 5 CODE*
//
// Send ENTIRE line to server
//n = write(server_sock, line, MAX);
//printf("client: wrote n=%d bytes; line=(%s)\n", n, line);
// Read a line from sock and show it
//n = read(server_sock, ans, MAX);
//printf("client: read n=%d bytes; echo=(%s)\n",n, ans);
}
}
int main()
{
if (client_init(NULL, 0, function_read) == -1)
return (-1);
client_loop();
}
/*--------------------------------------------------------------------
* ServiceStart
*
* each time starting the service, this is the entry point of the service.
* Start the service, certainly it is on server-mode
*
*-------------------------------------------------------------------- */
VOID ServiceStart (DWORD dwArgc, LPTSTR *lpszArgv) {
// report the status to the service control manager.
//
if ( !ReportStatusToSCMgr(
SERVICE_START_PENDING, // service state
NO_ERROR, // exit code
3000) ) // wait hint
goto clean;
thread_Settings* ext_gSettings = new thread_Settings;
// Initialize settings to defaults
Settings_Initialize( ext_gSettings );
// read settings from environment variables
Settings_ParseEnvironment( ext_gSettings );
// read settings from command-line parameters
Settings_ParseCommandLine( dwArgc, lpszArgv, ext_gSettings );
// report the status to the service control manager.
//
if ( !ReportStatusToSCMgr(
SERVICE_START_PENDING, // service state
NO_ERROR, // exit code
3000) ) // wait hint
goto clean;
// if needed, redirect the output into a specified file
if ( !isSTDOUT( ext_gSettings ) ) {
redirect( ext_gSettings->mOutputFileName );
}
// report the status to the service control manager.
//
if ( !ReportStatusToSCMgr(
SERVICE_START_PENDING, // service state
NO_ERROR, // exit code
3000) ) // wait hint
goto clean;
// initialize client(s)
if ( ext_gSettings->mThreadMode == kMode_Client ) {
client_init( ext_gSettings );
}
// start up the reporter and client(s) or listener
{
thread_Settings *into = NULL;
#ifdef HAVE_THREAD
Settings_Copy( ext_gSettings, &into );
into->mThreadMode = kMode_Reporter;
into->runNow = ext_gSettings;
#else
into = ext_gSettings;
#endif
thread_start( into );
}
// report the status to the service control manager.
//
if ( !ReportStatusToSCMgr(
SERVICE_RUNNING, // service state
NO_ERROR, // exit code
0) ) // wait hint
goto clean;
clean:
// wait for other (client, server) threads to complete
thread_joinall();
}
/* -------------------------------------------------------------------
* main()
* Entry point into Iperf
*
* sets up signal handlers
* initialize global locks and conditions
* parses settings from environment and command line
* starts up server or client thread
* waits for all threads to complete
* ------------------------------------------------------------------- */
int main( int argc, char **argv ) {
#ifdef WIN32
// Start winsock
WSADATA wsaData;
int rc;
#endif
// Set SIGTERM and SIGINT to call our user interrupt function
my_signal( SIGTERM, Sig_Interupt );
my_signal( SIGINT, Sig_Interupt );
#ifndef WIN32 // SIGALRM=14, _NSIG=3...
my_signal( SIGALRM, Sig_Interupt );
#endif
#ifndef WIN32
// Ignore broken pipes
signal(SIGPIPE,SIG_IGN);
#endif
#ifdef WIN32
// Start winsock
rc = WSAStartup( 0x202, &wsaData );
WARN_errno( rc == SOCKET_ERROR, "WSAStartup" );
if (rc == SOCKET_ERROR)
return 0;
// Tell windows we want to handle our own signals
SetConsoleCtrlHandler( sig_dispatcher, true );
#endif
// Initialize global mutexes and conditions
Condition_Initialize ( &ReportCond );
Condition_Initialize ( &ReportDoneCond );
Mutex_Initialize( &groupCond );
Mutex_Initialize( &clients_mutex );
// Initialize the thread subsystem
thread_init( );
// Initialize the interrupt handling thread to 0
sThread = thread_zeroid();
// perform any cleanup when quitting Iperf
atexit( cleanup );
// Allocate the "global" settings
thread_Settings* ext_gSettings = new thread_Settings;
// Initialize settings to defaults
Settings_Initialize( ext_gSettings );
// read settings from environment variables
Settings_ParseEnvironment( ext_gSettings );
// read settings from command-line parameters
Settings_ParseCommandLine( argc, argv, ext_gSettings );
// Check for either having specified client or server
if ( ext_gSettings->mThreadMode == kMode_Client
|| ext_gSettings->mThreadMode == kMode_Listener ) {
#ifdef WIN32
// Start the server as a daemon
// Daemon mode for non-windows in handled
// in the listener_spawn function
if ( isDaemon( ext_gSettings ) ) {
CmdInstallService(argc, argv);
return 0;
}
// Remove the Windows service if requested
if ( isRemoveService( ext_gSettings ) ) {
// remove the service
if ( CmdRemoveService() ) {
fprintf(stderr, "IPerf Service is removed.\n");
return 0;
}
}
#endif
// initialize client(s)
if ( ext_gSettings->mThreadMode == kMode_Client ) {
client_init( ext_gSettings );
}
#ifdef HAVE_THREAD
// start up the reporter and client(s) or listener
{
thread_Settings *into = NULL;
// Create the settings structure for the reporter thread
Settings_Copy( ext_gSettings, &into );
into->mThreadMode = kMode_Reporter;
// Have the reporter launch the client or listener
into->runNow = ext_gSettings;
// Start all the threads that are ready to go
thread_start( into );
}
#else
// No need to make a reporter thread because we don't have threads
thread_start( ext_gSettings );
#endif
} else {
// neither server nor client mode was specified
// print usage and exit
#ifdef WIN32
// In Win32 we also attempt to start a previously defined service
// Starting in 2.0 to restart a previously defined service
// you must call iperf with "iperf -D" or using the environment variable
SERVICE_TABLE_ENTRY dispatchTable[] =
{
{ TEXT(SZSERVICENAME), (LPSERVICE_MAIN_FUNCTION)service_main},
{ NULL, NULL}
};
// Only attempt to start the service if "-D" was specified
if ( !isDaemon(ext_gSettings) ||
// starting the service by SCM, there is no arguments will be passed in.
// the arguments will pass into Service_Main entry.
!StartServiceCtrlDispatcher(dispatchTable) )
// If the service failed to start then print usage
#endif
fprintf( stderr, usage_short, argv[0], argv[0] );
return 0;
}
// wait for other (client, server) threads to complete
thread_joinall();
// all done!
return 0;
} // end main
int main(void)
{
log_init();
leds_init();
timer_init();
counter_init();
buttons_init();
ble_stack_init();
gap_params_init();
conn_params_init();
gatt_init();
advertising_data_set();
server_init();
client_init();
// Default ATT MTU size and connection interval are set at compile time.
gatt_mtu_set(m_test_params.att_mtu);
// Data Length Extension (DLE) is on by default.
// Enable the Connection Event Length Extension.
conn_evt_len_ext_set(m_test_params.conn_evt_len_ext_enabled);
NRF_LOG_INFO("ATT MTU example started.\r\n");
NRF_LOG_INFO("Press button 3 on the board connected to the PC.\r\n");
NRF_LOG_INFO("Press button 4 on other board.\r\n");
NRF_LOG_FLUSH();
board_role_select();
if (m_board_role == BOARD_TESTER)
{
m_print_menu = true;
}
if (m_board_role == BOARD_DUMMY)
{
advertising_start();
scan_start();
}
// Enter main loop.
NRF_LOG_DEBUG("Entering main loop.\r\n");
for (;;)
{
if (m_print_menu)
{
menu_print();
}
if (is_test_ready())
{
m_run_test = true;
test_run();
}
if (!NRF_LOG_PROCESS())
{
wait_for_event();
}
}
}
static struct ropa_client *
client_query (uint32_t host, uint16_t port)
{
struct ropa_client *c, *c_new;
int ret;
c = client_query_notalkback(host, port);
if (c == NULL) {
interfaceAddr remote;
struct rx_connection *conn = NULL;
c = obtain_client();
assert (c->state == ROPAC_FREE && c->li == NULL);
c->state = ROPAC_LOOKUP_U;
c->flags |= ROPAF_LOOKUP;
client_init (c, host, port, NULL, NULL);
conn = rx_NewConnection (host, port, CM_SERVICE_ID,
rxnull_NewClientSecurityObject(),
0);
if (conn == NULL) {
free(c);
return NULL;
}
retry:
switch (c->state) {
case ROPAC_DEAD:
c->li = listaddtail (lru_clients, c);
ret = ENETDOWN;
break;
case ROPAC_LOOKUP_U:
ret = RXAFSCB_WhoAreYou (conn, &remote);
if (ret == RXGEN_OPCODE) {
c->state = ROPAC_LOOKUP;
goto retry;
} else if (ret == RX_CALL_DEAD) {
c->state = ROPAC_DEAD;
goto retry;
} else {
struct ropa_client ckey;
ckey.uuid = remote.uuid;
c_new = hashtabsearch (ht_clients_uuid, &ckey);
if (c_new == NULL) {
client_init (c, host, port, &remote.uuid, NULL);
ret = RXAFSCB_InitCallBackState3(conn, &server_uuid);
} else {
client_update_interfaces (c_new, host, port, &remote);
disconnect_client (c);
c = c_new;
listdel(lru_clients, c->li);
c->li = NULL;
}
}
break;
case ROPAC_LOOKUP: {
afsUUID uuid;
ret = RXAFSCB_InitCallBackState(conn);
if (ret == RX_CALL_DEAD) {
c->state = ROPAC_DEAD;
goto retry;
}
uuid_init_simple (&uuid, host);
client_init (c, host, port, &uuid, NULL);
break;
}
default:
exit(-1);
}
rx_DestroyConnection (conn);
if ((c->flags & ROPAF_WAITING) != 0)
LWP_NoYieldSignal (c);
c->flags &= ~(ROPAF_LOOKUP|ROPAF_WAITING);
if (ret) {
assert (c->li != NULL);
return NULL;
}
assert (c->li == NULL);
c->li = listaddhead (lru_clients, c);
} else { /* c != NULL */
if ((c->flags & ROPAF_LOOKUP) != 0) {
c->flags |= ROPAF_WAITING;
LWP_WaitProcess (c);
}
assert (c->li != NULL);
}
return c;
}
int client_main(int argc, char **argv) {
if (argc < 4) {
fprintf(stderr, "Usage: wetalk -c <ip> <uid> <password>\n"
"Or : wetalk -r <ip> <username> <password>\n");
return wetalk_usage("wetalk");
}
int uid = 0;
char *ipaddr = argv[1];
char *password = argv[3];
if (strlen(password) >= PASSWORD_MAX) {
fprintf(stderr, "错误的密码长度\n");
return 1;
}
if (!client_init(argv[1], on_msg_recv)) {
wetalk_error("初始化客户端失败\n");
}
if (!strcmp(argv[0], "-r")) {
uid = client_register(argv[2], password);
if (uid > 0) {
fprintf(stderr, "注册成功，您的 uid 为: %d\n这是以后登陆时必要的信息，请牢记\n回车键以继续", uid);
getchar();
} else {
fprintf(stderr, "注册失败\n");
return 1;
}
} else {
uid = atoi(argv[2]);
if (uid <= 0) {
fprintf(stderr, "错误的uid\n");
return 1;
}
}
if (!client_login(uid, password)) {
wetalk_error("登陆失败\n");
}
client_main_run = true;
int r;
setlocale(LC_ALL, "");
initscr();
getmaxyx(stdscr, window_y, window_x);
char input[BUFFER_SIZE] = {0};
while(client_main_run) {
draw_editarea();
getnstr(input, BUFFER_SIZE - 1);
r = strlen(input);
input[r] = '\0';
if (r > 0) {
client_send(input);
}
}
endwin();
return 0;
}
int main(int argc, char *argv[])
{
int listenfd;
int res = 0;
int lfd;
struct flock lock;
char pids[10];
parse_opts(argc, argv);
argc -= optind;
argv += optind;
if (!foreground) {
verbose += LL_WARNING;
log_enable_syslog();
} else {
verbose += LL_NOTICE;
}
/* set log level to specified verbosity */
log_level = verbose;
usbmuxd_log(LL_NOTICE, "usbmuxd v%s starting up", PACKAGE_VERSION);
should_exit = 0;
should_discover = 0;
set_signal_handlers();
signal(SIGPIPE, SIG_IGN);
res = lfd = open(lockfile, O_WRONLY|O_CREAT, 0644);
if(res == -1) {
usbmuxd_log(LL_FATAL, "Could not open lockfile");
goto terminate;
}
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
lock.l_pid = 0;
fcntl(lfd, F_GETLK, &lock);
close(lfd);
if (lock.l_type != F_UNLCK) {
if (opt_exit) {
if (lock.l_pid && !kill(lock.l_pid, 0)) {
usbmuxd_log(LL_NOTICE, "Sending signal %d to instance with pid %d", exit_signal, lock.l_pid);
res = 0;
if (kill(lock.l_pid, exit_signal) < 0) {
usbmuxd_log(LL_FATAL, "Could not deliver signal %d to pid %d", exit_signal, lock.l_pid);
res = -1;
}
goto terminate;
} else {
usbmuxd_log(LL_ERROR, "Could not determine pid of the other running instance!");
res = -1;
goto terminate;
}
} else {
if (!opt_disable_hotplug) {
usbmuxd_log(LL_ERROR, "Another instance is already running (pid %d). exiting.", lock.l_pid);
res = -1;
} else {
usbmuxd_log(LL_NOTICE, "Another instance is already running (pid %d). Telling it to check for devices.", lock.l_pid);
if (lock.l_pid && !kill(lock.l_pid, 0)) {
usbmuxd_log(LL_NOTICE, "Sending signal SIGUSR2 to instance with pid %d", lock.l_pid);
res = 0;
if (kill(lock.l_pid, SIGUSR2) < 0) {
usbmuxd_log(LL_FATAL, "Could not deliver SIGUSR2 to pid %d", lock.l_pid);
res = -1;
}
} else {
usbmuxd_log(LL_ERROR, "Could not determine pid of the other running instance!");
res = -1;
}
}
goto terminate;
}
}
unlink(lockfile);
if (opt_exit) {
usbmuxd_log(LL_NOTICE, "No running instance found, none killed. Exiting.");
goto terminate;
}
if (!foreground) {
if ((res = daemonize()) < 0) {
fprintf(stderr, "usbmuxd: FATAL: Could not daemonize!\n");
usbmuxd_log(LL_FATAL, "Could not daemonize!");
goto terminate;
}
}
// now open the lockfile and place the lock
res = lfd = open(lockfile, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, 0644);
if(res < 0) {
usbmuxd_log(LL_FATAL, "Could not open lockfile");
goto terminate;
}
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
if ((res = fcntl(lfd, F_SETLK, &lock)) < 0) {
usbmuxd_log(LL_FATAL, "Lockfile locking failed!");
goto terminate;
}
sprintf(pids, "%d", getpid());
if ((size_t)(res = write(lfd, pids, strlen(pids))) != strlen(pids)) {
usbmuxd_log(LL_FATAL, "Could not write pidfile!");
if(res >= 0)
res = -2;
goto terminate;
}
// set number of file descriptors to higher value
struct rlimit rlim;
getrlimit(RLIMIT_NOFILE, &rlim);
rlim.rlim_max = 65536;
setrlimit(RLIMIT_NOFILE, (const struct rlimit*)&rlim);
usbmuxd_log(LL_INFO, "Creating socket");
res = listenfd = create_socket();
if(listenfd < 0)
goto terminate;
#ifdef HAVE_LIBIMOBILEDEVICE
const char* userprefdir = config_get_config_dir();
struct stat fst;
memset(&fst, '\0', sizeof(struct stat));
if (stat(userprefdir, &fst) < 0) {
if (mkdir(userprefdir, 0775) < 0) {
usbmuxd_log(LL_FATAL, "Failed to create required directory '%s': %s", userprefdir, strerror(errno));
res = -1;
goto terminate;
}
if (stat(userprefdir, &fst) < 0) {
usbmuxd_log(LL_FATAL, "stat() failed after creating directory '%s': %s", userprefdir, strerror(errno));
res = -1;
goto terminate;
}
}
// make sure permission bits are set correctly
if (fst.st_mode != 02775) {
if (chmod(userprefdir, 02775) < 0) {
usbmuxd_log(LL_WARNING, "chmod(%s, 02775) failed: %s", userprefdir, strerror(errno));
}
}
#endif
// drop elevated privileges
if (drop_privileges && (getuid() == 0 || geteuid() == 0)) {
struct passwd *pw;
if (!drop_user) {
usbmuxd_log(LL_FATAL, "No user to drop privileges to?");
res = -1;
goto terminate;
}
pw = getpwnam(drop_user);
if (!pw) {
usbmuxd_log(LL_FATAL, "Dropping privileges failed, check if user '%s' exists!", drop_user);
res = -1;
goto terminate;
}
if (pw->pw_uid == 0) {
usbmuxd_log(LL_INFO, "Not dropping privileges to root");
} else {
#ifdef HAVE_LIBIMOBILEDEVICE
/* make sure the non-privileged user has proper access to the config directory */
if ((fst.st_uid != pw->pw_uid) || (fst.st_gid != pw->pw_gid)) {
if (chown(userprefdir, pw->pw_uid, pw->pw_gid) < 0) {
usbmuxd_log(LL_WARNING, "chown(%s, %d, %d) failed: %s", userprefdir, pw->pw_uid, pw->pw_gid, strerror(errno));
}
}
#endif
if ((res = initgroups(drop_user, pw->pw_gid)) < 0) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set supplementary groups)");
goto terminate;
}
if ((res = setgid(pw->pw_gid)) < 0) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set group ID to %d)", pw->pw_gid);
goto terminate;
}
if ((res = setuid(pw->pw_uid)) < 0) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges (cannot set user ID to %d)", pw->pw_uid);
goto terminate;
}
// security check
if (setuid(0) != -1) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges properly!");
res = -1;
goto terminate;
}
if (getuid() != pw->pw_uid || getgid() != pw->pw_gid) {
usbmuxd_log(LL_FATAL, "Failed to drop privileges properly!");
res = -1;
goto terminate;
}
usbmuxd_log(LL_NOTICE, "Successfully dropped privileges to '%s'", drop_user);
}
}
client_init();
device_init();
usbmuxd_log(LL_INFO, "Initializing USB");
if((res = usb_init()) < 0)
goto terminate;
usbmuxd_log(LL_INFO, "%d device%s detected", res, (res==1)?"":"s");
usbmuxd_log(LL_NOTICE, "Initialization complete");
if (report_to_parent)
if((res = notify_parent(0)) < 0)
goto terminate;
if(opt_disable_hotplug) {
usbmuxd_log(LL_NOTICE, "Automatic device discovery on hotplug disabled.");
usb_autodiscover(0); // discovery to be triggered by new instance
}
if (opt_enable_exit) {
usbmuxd_log(LL_NOTICE, "Enabled exit on SIGUSR1 if no devices are attached. Start a new instance with \"--exit\" to trigger.");
}
res = main_loop(listenfd);
if(res < 0)
usbmuxd_log(LL_FATAL, "main_loop failed");
usbmuxd_log(LL_NOTICE, "usbmuxd shutting down");
device_kill_connections();
usb_shutdown();
device_shutdown();
client_shutdown();
usbmuxd_log(LL_NOTICE, "Shutdown complete");
terminate:
log_disable_syslog();
if (res < 0)
res = -res;
else
res = 0;
if (report_to_parent)
notify_parent(res);
return res;
}
int
main(int argc, char **argv)
{
struct client_ctx cctx;
struct msg_command_data cmddata;
struct buffer *b;
struct cmd_list *cmdlist;
struct cmd *cmd;
struct pollfd pfd;
struct hdr hdr;
const char *shell;
struct passwd *pw;
char *path, *label, *cause, *home, *pass = NULL;
char cwd[MAXPATHLEN];
int retcode, opt, flags, unlock, start_server;
unlock = flags = 0;
label = path = NULL;
while ((opt = getopt(argc, argv, "28df:L:qS:uUVv")) != -1) {
switch (opt) {
case '2':
flags |= IDENTIFY_256COLOURS;
flags &= ~IDENTIFY_88COLOURS;
break;
case '8':
flags |= IDENTIFY_88COLOURS;
flags &= ~IDENTIFY_256COLOURS;
break;
case 'f':
cfg_file = xstrdup(optarg);
break;
case 'L':
if (path != NULL) {
log_warnx("-L and -S cannot be used together");
exit(1);
}
if (label != NULL)
xfree(label);
label = xstrdup(optarg);
break;
case 'S':
if (label != NULL) {
log_warnx("-L and -S cannot be used together");
exit(1);
}
if (path != NULL)
xfree(path);
path = xstrdup(optarg);
break;
case 'q':
be_quiet = 1;
break;
case 'u':
flags |= IDENTIFY_UTF8;
break;
case 'U':
unlock = 1;
break;
case 'd':
flags |= IDENTIFY_HASDEFAULTS;
break;
case 'v':
debug_level++;
break;
case 'V':
printf("%s " BUILD "\n", __progname);
exit(0);
default:
usage();
}
}
argc -= optind;
argv += optind;
log_open_tty(debug_level);
siginit();
options_init(&global_options, NULL);
options_set_number(&global_options, "bell-action", BELL_ANY);
options_set_number(&global_options, "buffer-limit", 9);
options_set_number(&global_options, "display-time", 750);
options_set_number(&global_options, "history-limit", 2000);
options_set_number(&global_options, "message-bg", 3);
options_set_number(&global_options, "message-fg", 0);
options_set_number(&global_options, "message-attr", GRID_ATTR_REVERSE);
options_set_number(&global_options, "prefix", META);
options_set_number(&global_options, "repeat-time", 500);
options_set_number(&global_options, "set-titles", 1);
options_set_number(&global_options, "lock-after-time", 0);
options_set_number(&global_options, "set-remain-on-exit", 0);
options_set_number(&global_options, "status", 1);
options_set_number(&global_options, "status-bg", 2);
options_set_number(&global_options, "status-fg", 0);
options_set_number(&global_options, "status-attr", GRID_ATTR_REVERSE);
options_set_number(&global_options, "status-interval", 15);
options_set_number(&global_options, "status-left-length", 10);
options_set_number(&global_options, "status-right-length", 40);
options_set_string(&global_options, "status-left", "[#S]");
options_set_string(
&global_options, "status-right", "\"#24T\" %%H:%%M %%d-%%b-%%y");
options_set_number(&global_options, "status-keys", MODEKEY_EMACS);
options_init(&global_window_options, NULL);
options_set_number(&global_window_options, "aggressive-resize", 0);
options_set_number(&global_window_options, "clock-mode-colour", 4);
options_set_number(&global_window_options, "clock-mode-style", 1);
options_set_number(&global_window_options, "force-height", 0);
options_set_number(&global_window_options, "force-width", 0);
options_set_number(&global_window_options, "automatic-rename", 1);
options_set_number(&global_window_options, "mode-bg", 3);
options_set_number(&global_window_options, "mode-fg", 0);
options_set_number(
&global_window_options, "mode-attr", GRID_ATTR_REVERSE);
options_set_number(&global_window_options, "mode-keys", MODEKEY_EMACS);
options_set_number(&global_window_options, "monitor-activity", 0);
options_set_number(&global_window_options, "utf8", 0);
options_set_number(&global_window_options, "xterm-keys", 0);
options_set_number(&global_window_options, "remain-on-exit", 0);
options_set_number(&global_window_options, "window-status-bg", 8);
options_set_number(&global_window_options, "window-status-fg", 8);
options_set_number(&global_window_options, "window-status-attr", 0);
if (cfg_file == NULL) {
home = getenv("HOME");
if (home == NULL || *home == '\0') {
pw = getpwuid(getuid());
if (pw != NULL)
home = pw->pw_dir;
endpwent();
}
xasprintf(&cfg_file, "%s/%s", home, DEFAULT_CFG);
if (access(cfg_file, R_OK) != 0) {
xfree(cfg_file);
cfg_file = NULL;
}
} else {
if (access(cfg_file, R_OK) != 0) {
log_warn("%s", cfg_file);
exit(1);
}
}
if (label == NULL)
label = xstrdup("default");
if (path == NULL && (path = makesockpath(label)) == NULL) {
log_warn("can't create socket");
exit(1);
}
xfree(label);
shell = getenv("SHELL");
if (shell == NULL || *shell == '\0') {
pw = getpwuid(getuid());
if (pw != NULL)
shell = pw->pw_shell;
endpwent();
if (shell == NULL || *shell == '\0')
shell = _PATH_BSHELL;
}
options_set_string(
&global_options, "default-command", "exec %s", shell);
if (getcwd(cwd, sizeof cwd) == NULL) {
log_warn("getcwd");
exit(1);
}
options_set_string(&global_options, "default-path", "%s", cwd);
if (unlock) {
if (argc != 0) {
log_warnx("can't specify a command when unlocking");
exit(1);
}
cmdlist = NULL;
if ((pass = getpass("Password: "******"%s", cause);
exit(1);
}
}
start_server = 0;
TAILQ_FOREACH(cmd, cmdlist, qentry) {
if (cmd->entry->flags & CMD_STARTSERVER) {
start_server = 1;
break;
}
}
}
memset(&cctx, 0, sizeof cctx);
if (client_init(path, &cctx, start_server, flags) != 0)
exit(1);
xfree(path);
b = buffer_create(BUFSIZ);
if (unlock) {
cmd_send_string(b, pass);
client_write_server(
&cctx, MSG_UNLOCK, BUFFER_OUT(b), BUFFER_USED(b));
} else {
cmd_list_send(cmdlist, b);
cmd_list_free(cmdlist);
client_fill_session(&cmddata);
client_write_server2(&cctx, MSG_COMMAND,
&cmddata, sizeof cmddata, BUFFER_OUT(b), BUFFER_USED(b));
}
buffer_destroy(b);
retcode = 0;
for (;;) {
pfd.fd = cctx.srv_fd;
pfd.events = POLLIN;
if (BUFFER_USED(cctx.srv_out) > 0)
pfd.events |= POLLOUT;
if (poll(&pfd, 1, INFTIM) == -1) {
if (errno == EAGAIN || errno == EINTR)
continue;
fatal("poll failed");
}
if (buffer_poll(&pfd, cctx.srv_in, cctx.srv_out) != 0)
goto out;
restart:
if (BUFFER_USED(cctx.srv_in) < sizeof hdr)
continue;
memcpy(&hdr, BUFFER_OUT(cctx.srv_in), sizeof hdr);
if (BUFFER_USED(cctx.srv_in) < (sizeof hdr) + hdr.size)
continue;
buffer_remove(cctx.srv_in, sizeof hdr);
switch (hdr.type) {
case MSG_EXIT:
case MSG_SHUTDOWN:
goto out;
case MSG_ERROR:
retcode = 1;
/* FALLTHROUGH */
case MSG_PRINT:
if (hdr.size > INT_MAX - 1)
fatalx("bad MSG_PRINT size");
log_info("%.*s",
(int) hdr.size, BUFFER_OUT(cctx.srv_in));
if (hdr.size != 0)
buffer_remove(cctx.srv_in, hdr.size);
goto restart;
case MSG_READY:
retcode = client_main(&cctx);
goto out;
default:
fatalx("unexpected command");
}
}
out:
options_free(&global_options);
options_free(&global_window_options);
close(cctx.srv_fd);
buffer_destroy(cctx.srv_in);
buffer_destroy(cctx.srv_out);
#ifdef DEBUG
xmalloc_report(getpid(), "client");
#endif
return (retcode);
}
int main(int argc, char **argv)
{
//initial the client
if (argc>1)
port = atoi(argv[1]);
int info_fd = client_init(SERVER_IP);
char filename[FILENAME_MAXLEN] = {0};
printf("BLOCKSIZE= %d\n",BLOCKSIZE);
printf("Input filename : ");
scanf("%s",filename);
int fd=0;
if((fd = open(filename, O_RDWR)) == -1 )
{
printf("open erro ！\n");
exit(-1);
}
/*Timer*/
printf("Timer start!\n");
time_t t_start, t_end;
t_start=time(NULL);
//send file info
struct stat filestat;
fstat(fd ,&filestat);
int last_bs=0;
struct fileinfo finfo;
send_fileinfo(info_fd, filename, &filestat, &finfo, &last_bs);
//
char id_buf[INT_SIZE] = {0};
int n=0;
for(n=0; n<INT_SIZE; n++){
read(info_fd, &id_buf[n], 1);
}
int freeid = *((int *)id_buf);
printf("freeid = %d\n", freeid);
//map .
mbegin = (char *)mmap(NULL, filestat.st_size, PROT_WRITE|PROT_READ, MAP_SHARED, fd , 0);
close(fd);
//add task to the list
int j=0, num=finfo.count, offset=0;
pthread_t pid[num];
memset(pid, 0, num*sizeof(pthread_t));
int head_len = sizeof(struct head);
// file can be slipt into blocks
if(last_bs == 0){
for(j=0; j<num; j++){
struct head * p_fhead = new_fb_head(filename, freeid, &offset);
if (pthread_create(&pid[j], NULL, send_filedata, (void *)p_fhead) != 0){
printf("%s:pthread_create failed, errno:%d, error:%s\n", __FUNCTION__, errno, strerror(errno));
exit(-1);
}
}
}
//file cannot slipt into blocks
else{
for(j=0; j<num-1; j++){
struct head * p_fhead = new_fb_head(filename, freeid, &offset);
if (pthread_create(&pid[j], NULL, send_filedata, (void *)p_fhead) != 0){
printf("%s:pthread_create failed, errno:%d, error:%s\n", __FUNCTION__, errno, strerror(errno));
exit(-1);
}
}
//the last block
struct head * p_fhead = (struct head *)malloc(head_len);
bzero(p_fhead, head_len);
strcpy(p_fhead->filename, filename);
p_fhead->id = freeid;
p_fhead->offset = offset;
p_fhead->bs = last_bs;
if (pthread_create(&pid[j], NULL, send_filedata, (void *)p_fhead) != 0){
printf("%s:pthread_create failed, errno:%d, error:%s\n", __FUNCTION__, errno, strerror(errno));
exit(-1);
}
}
//join all the pthread
for (j = 0; j < num; ++j) {
pthread_join(pid[j], NULL);
}
//calculate the time for send file
t_end=time(NULL);
printf("Master prosess exit!\n");
printf("TIME:%.0fs\n",difftime(t_end,t_start));
return 0;
}
uint8_t client_do_prompt() {
char cmd[17];
//scanf("%16s",cmd);
scan_key(cmd,17);
if (strcmp(cmd,"init")==0) {
client_init();
print_ok_nl();
return 1;
}
if (strcmp(cmd,"loop")==0) {
uint16_t count = scan_uint16();
if (count == 0) {
print(PSTR("client loop...."));
while(!uart_read_ready()) {
client_loop();
}
print(PSTR(" end\n\r"));
} else {
while(count--) {
print_char('.');
client_loop();
}
}
return 1;
}
if (strcmp(cmd,"autotune")==0) {
client_autotune();
return 1;
}
if (strcmp(cmd,"channel")==0) {
uint8_t c = scan_uint8();
client_select_channel(c);
return 1;
}
if (strcmp(cmd,"check")==0) {
uint8_t c = scan_uint8();
if (client_check_for_server(c)) {
print(PSTR("ok\r\n"));
} else {
print(PSTR("fail\r\n"));
}
return 1;
}
if (strcmp(cmd,"pad")==0) {
uint8_t l = client_read_pad();
print_hb(0,l);
while(!uart_read_ready()) {
uint8_t d = client_read_pad();
if (d!=l) {
l = d;
print_hb(PSTR(" "), d);
}
}
return 1;
}
if (strcmp(cmd,"reset_stats")==0) {
stats_ok = 0;
stats_inv_seq = 0;
stats_bad_crc = 0;
stats_timeout = 0;
print(PSTR("stat reset ok"));
return 1;
}
if (strcmp(cmd,"stats")==0) {
print_dw(PSTR("ok: "), stats_ok);
print_dw(PSTR(" inv_seq: "), stats_inv_seq);
print_dw(PSTR(" bad_crc: "), stats_bad_crc);
print_dw(PSTR(" timeout: "), stats_timeout);
print_nl();
return 1;
}
return 1;
}
