static void tell_emacs_to_resume(int sig) { char buffer[GSERV_BUFSZ + 1]; int sz; int s; /* socket / msqid to server */ int connect_type; /* CONN_UNIX, CONN_INTERNET, or ONN_IPC */ /* Why is SYSV so retarded? */ /* We want emacs to realize that we are resuming */ #ifdef SIGCONT signal(SIGCONT, tell_emacs_to_resume); #endif connect_type = make_connection(NULL, 0, &s); SNPRINTF(sz, buffer, sizeof(buffer), "(gnuserv-eval '(resume-pid-console %d))", (int)getpid()); send_string(s, buffer); #ifdef SYSV_IPC if (connect_type == (int)CONN_IPC) disconnect_from_ipc_server(s, msgp, FALSE); #else /* !SYSV_IPC */ if (connect_type != (int)CONN_IPC) disconnect_from_server(s, FALSE); #endif /* !SYSV_IPC */ }
static int cmd_disconnect (int __argc, char **__argv) { if (__argc!=1) console_log ("Usage: disconnect\n"); else disconnect_from_server (); return 0; }
nvqrReturn_t nvqr_disconnect(NVQRConnection *connection) { if (disconnect_from_server(*connection)) { close_client_connection(*connection); destroy_client(*connection); close_server_connection(connection->server_handle); free(connection->process_name); return NVQR_SUCCESS; } return NVQR_ERROR_UNKNOWN; }
static int cmd_ipc (int __argc, char **__argv) { char cmd[4096], dummy[1024]; int sock=console_get_socket (); if (__argc!=2) { console_log ("Usage: ipc <ipc command>\n"); return 0; } strcpy (cmd, __argv[1]); if (!strcmp (cmd, "")) return 0; if (sock>0) { char ans[65536]; int a; if ((a=sock_answer (sock, "%s\n", cmd))) goto __fail_; if (sock_read (sock, 65536, ans)<0 || MSG_DISCONNECT (ans)) goto __fail_; console_log ("%s", ans); } else console_log ("Not connected to server.\n"); trim (cmd, dummy); if (!strcmp (dummy, "exit")) disconnect_from_server (); return 0; __fail_: disconnect_from_server (); return 0; }
bool Client::stop_client() { if(_V_is_running) { disconnect_from_server(); clear(); enet_host_destroy(_V_client_host); _V_client_host=nullptr; _V_is_running=false; return true; } return false; }
int main(int argc, char **argv) { static acs_cli_info_t ai; int rc; /* Initalise our context object */ memset(&ai, 0, sizeof(ai)); ai.wl_ifname = DEFAULT_WL_IFNAME; ai.server_host = DEFAULT_SERVER_HOST; ai.server_port = DEFAULT_SERVER_PORT; ai.socket = -1; for (rc = 0; rc < CMDARG_MAX; ++rc) { ai.cmdarg[rc] = ""; } rc = parse_commandline(&ai, argc, argv); if (rc != BCME_OK) { return rc; } switch (ai.action) { case ACTION_SHOW_COMMANDS: rc = show_command_list(); break; case ACTION_SHOW_USAGE: rc = BCME_OK; usage(argv[0]); break; case ACTION_REPORT_VARIABLES: rc = report_all_variables(&ai); break; case ACTION_REPORT_EVERYTHING: rc = report_everything(&ai); break; case ACTION_DO_COMMAND: rc = connect_to_server(&ai); if (rc == BCME_OK) { rc = do_command_response(&ai); disconnect_from_server(&ai); } break; } return rc; }
void on_connect_toggled (GtkToggleButton *__self, gpointer __user_data) { BOOL auth=gtk_toggle_button_get_active ((GtkToggleButton*)lookup_widget (main_window, "login_at_connect")); char *server = (char*)gtk_entry_get_text ((GtkEntry*)lookup_widget (main_window, "server")); char *login = (char*)gtk_entry_get_text ((GtkEntry*)lookup_widget (main_window, "login")); char *password = (char*)gtk_entry_get_text ((GtkEntry*)lookup_widget (main_window, "password")); if (gtk_toggle_button_get_active (__self)) { if (!connect_to_server (server, auth, login, password)) gtk_toggle_button_set_active (__self, FALSE); } else { disconnect_from_server (); } }
int main(int argc, char* argv[]) { cout << "processing configuration options ..." << endl; // pointers to options we will create for the grid server program option_t* opt_server_host = 0; option_t* opt_connect_port = 0; const option_level_cnt = 3; option_group_t options(option_level_cnt); W_COERCE(options.add_option("connect_port", "1024 < integer < 65535", "1234", "port for connecting to grid server", false, option_t::set_value_long, opt_connect_port)); W_COERCE(options.add_option("server_host", "host address", "localhost", "address of host running server", false, option_t::set_value_charstr, opt_server_host)); if (init_config_options(options, "client", argc, argv)) { usage(options); exit(1); } // there should not be any other command line arguments if (argc > 1) { usage(options); exit(1); } int port = strtol(opt_connect_port->value(), 0, 0); cout << "trying to connect to server at port " << port<< endl; if (!connect_to_server(opt_server_host->value(), port)) { cerr << "Shutting down due to connection failure" << endl; exit(1); } process_user_commands(); disconnect_from_server(); cout << "Finished!" << endl; return 0; }
/* * Each bot's entry point. 'arg' must be a dynamically allocated THREAD_ARG * pointer. The pointer is freed by the new thread. */ void* BotEntryPoint(void *arg) { THREAD_DATA *td = (THREAD_DATA*)arg; /* set the tls key */ pthread_setspecific(g_tls_key, td); init_thread_data(td); db_instance_init(); cmd_instance_init(td); player_instance_init(td); libman_instance_init(td); /* load the core pseudo-plugin */ libman_load_library(td, NULL); /* load the bots libraries */ int num_plugins = DelimCount(td->libstring, ' ') + 1; for (int i = 0; i < num_plugins; ++i) { char libname[64]; DelimArgs(libname, 64, td->libstring, i, ' ', false); if (strlen(libname) > 0) { libman_load_library(td, libname); } } /* mainloop */ mainloop(td); disconnect_from_server(td); libman_instance_shutdown(td); player_instance_shutdown(td); cmd_instance_shutdown(td); db_instance_shutdown(); botman_bot_exiting(td->botman_handle); free_thread_data(td); free(td); return NULL; }
static int report_all_dumps(acs_cli_info_t *ctx) { int rc = BCME_OK; int i; ctx->cmdarg[CMDARG_COMMAND] = "dump"; for (i = 0; (dump_table[i].option && (rc == 0)); ++i) { rc = connect_to_server(ctx); if (rc == BCME_OK) { printf( "[ %s: dump %s ]\n", ctx->wl_ifname, dump_table[i].option ); ctx->cmdarg[CMDARG_PARAMETER] = dump_table[i].option; rc = do_command_response(ctx); disconnect_from_server(ctx); } } return rc; }
/** * @brief 将发送缓冲中的数据发送出去,同时接收一次网络中的数据 * @param * @return 0success -1failed */ int c_net_client_impl::do_io() { if(!m_inited) { return -1; } if(m_sock_fd < 0) { if(connect_to_server(m_timeout) != 0) { ERROR_LOG("can not connect now"); return -1; } } if(recv_data_from_server() < 0) { return -1; } if(m_send_buffer_len > 0) { int bytes_sent = send_to_server(m_sock_fd, m_send_buffer, m_send_buffer_len); if(bytes_sent > 0) { remove_data_from_send_buffer(bytes_sent); } else if(bytes_sent < 0) {/**< 连接遇到问题,关闭连接*/ disconnect_from_server(); return -1; } else { //nothing to do } } return 0; }
// Handle an incoming REJ( NME() ) message. void BaseBot::process_rej_nme_message( TokenMessage &incoming_message, TokenMessage &message_parameters ) { bool attempt_reconnect; // Whether to try and reconnect Token power_token = 0; // The token for the power to reconnect as int passcode = 0; // The passcode to reconnect as Token passcode_token; // The passcode as a token attempt_reconnect = get_reconnect_details( power_token, passcode ); if ( attempt_reconnect ) { // Send an IAM message passcode_token.set_number( passcode ); send_message_to_server( TOKEN_COMMAND_IAM & power_token & passcode_token ); } else { // Disconnect disconnect_from_server(); } }
static int report_everything(acs_cli_info_t *ctx) { int rc; rc = connect_to_server(ctx); if (rc == BCME_OK) { printf( "[ info ]\n" ); ctx->cmdarg[CMDARG_COMMAND] = "info"; rc = do_command_response(ctx); disconnect_from_server(ctx); } if (rc == BCME_OK) { rc = report_all_dumps(ctx); if (rc == BCME_OK) { rc = report_all_variables(ctx); } } return rc; }
static int report_all_variables(acs_cli_info_t *ctx) { int rc = BCME_OK; int i; ctx->cmdarg[CMDARG_COMMAND] = "get"; printf( "[ %s: acsd variables ]\n", ctx->wl_ifname ); for (i = 0; (acsd_variables[i] && (rc == BCME_OK)); ++i) { rc = connect_to_server(ctx); if (rc == BCME_OK) { printf( "%25s = ", acsd_variables[i] ); fflush(stdout); ctx->cmdarg[CMDARG_PARAMETER] = acsd_variables[i]; rc = do_command_response(ctx); disconnect_from_server(ctx); } } return rc; }
/** * @brief 从服务端接收数据 * @param * @return -1无法接收数据 >0 接收到的数据长度 */ int c_net_client_impl::recv_data_from_server() { if(m_recv_buffer_len >= (int)sizeof(m_recv_buffer)) {/**< 检查是否有足够的空间接收继续数据*/ return 0; } int bytes_recved = recv_from_server(m_sock_fd, m_recv_buffer + m_recv_buffer_len, sizeof(m_recv_buffer) - m_recv_buffer_len); if(bytes_recved < 0) { disconnect_from_server(); return -1; } else if(bytes_recved == 0) { //nothing to do } else { m_recv_buffer_len += bytes_recved; } return bytes_recved; }
static void mainloop(THREAD_DATA *td) { THREAD_DATA::net_t *n = td->net; ticks_ms_t acc, ticks, lticks; /* accumulator, current ticks, last iteration ticks */ int pktl; /* packet length */ uint8_t pkt[MAX_PACKET]; /* buffer space for a packet */ if (connect_to_server(td) != 0) { free_thread_data(td); LogFmt(OP_MOD, "Error performing initial connect"); return; } acc = 0; ticks = get_ticks_ms(); lticks = ticks; ticks_ms_t last_botman_checkin = ticks; ticks_ms_t last_botman_stopcheck = ticks; ticks_ms_t last_config_mtime_check = ticks; while (td->running >= 0) { ticks = get_ticks_ms(); acc += ticks - lticks; lticks = ticks; /* check in with the bot manager */ if (ticks - last_botman_checkin >= BOTMAN_CHECKIN_INTERVAL) { botman_bot_checkin(td->botman_handle); last_botman_checkin = ticks; } if (ticks - last_botman_stopcheck >= BOTMAN_STOPCHECK_INTERVAL) { if (botman_bot_shouldstop(td->botman_handle)) { td->running = -1; } last_botman_stopcheck = ticks; } /* flush out tick events to bots */ if (acc >= STEP_INTERVAL) { libman_expire_timers(td); while(acc >= STEP_INTERVAL) { /* event_tick */ libman_export_event(td, EVENT_TICK, NULL); acc -= STEP_INTERVAL; } } /* if the bot is disconnected, see if it is time to reconnect */ if (n->state == NS_DISCONNECTED) { if (ticks - n->ticks->disconnected > 60000) { free_thread_data(td); init_thread_data(td); connect_to_server(td); } else { usleep(50000); /* 50ms */ continue; } } /* see if the config file has been modified and if so send a reread event */ if (ticks - last_config_mtime_check >= CONFIG_MTIME_POLL_INTERVAL) { struct stat attr; memset(&attr, 0, sizeof(struct stat)); if (stat(td->config->filename, &attr) == 0) { if (td->config->last_modified_time != attr.st_mtime) { libman_export_event(td, EVENT_CONFIG_CHANGE, NULL); td->config->last_modified_time = attr.st_mtime; } } last_config_mtime_check = ticks; } /* use up to STEP_INTERVAL ms for the db thread */ ticks_ms_t ticks_taken = get_ticks_ms() - ticks; ticks_ms_t db_ticks = ticks_taken > STEP_INTERVAL ? STEP_INTERVAL : STEP_INTERVAL - ticks_taken; db_instance_export_events(db_ticks); /* read a packet or wait for a timeout */ ticks_taken = get_ticks_ms() - ticks; ticks_ms_t timeout = ticks_taken > STEP_INTERVAL ? 0 : STEP_INTERVAL - ticks_taken; while (poll(n->pfd, 1, (int)timeout) > 0) { /* process incoming packet, data is waiting */ pktl = (int)read(n->fd, pkt, MAX_PACKET); if (pktl >= 0) { ++n->stats->packets_read; n->ticks->last_pkt_received = get_ticks_ms(); if (n->encrypt->use_encryption) { if (pkt[0] == 0x00) { if (pktl >= 2) { decrypt_buffer(td, &pkt[2], pktl-2); } } else { decrypt_buffer(td, &pkt[1], pktl-1); } } if (td->debug->spew_packets) { spew_packet(pkt, pktl, DIR_INCOMING); } process_incoming_packet(td, pkt, pktl); } ticks_taken = get_ticks_ms() - ticks; timeout = timeout > ticks_taken ? timeout - ticks_taken : 0; } /* update the tick count after potential sleeping in poll() */ ticks = get_ticks_ms(); /* network state specfic actions */ if (n->state == NS_CONNECTING) { /* retransmit connection request if it was lost */ if (ticks - n->ticks->last_connection_request > 15000) { pkt_send_client_key(n->encrypt->client_key); n->ticks->last_connection_request = ticks; } } else if (ticks - n->ticks->last_pkt_received > 30*1000) { /* disconnect if no packets have been received for 30 seconds */ Log(OP_MOD, "No data received for 30 seconds, reconnecting..."); disconnect_from_server(td); continue; } /* transmit player position update if necessary */ if (n->state == NS_CONNECTED && td->in_arena) { if ((ticks - n->ticks->last_pos_update_sent > 100 && td->bot_ship != SHIP_SPECTATOR) || (ticks - n->ticks->last_pos_update_sent > 1000 && td->bot_ship == SHIP_SPECTATOR)) { pkt_send_position_update(td->bot_pos->x, td->bot_pos->y, td->bot_vel->x, td->bot_vel->y); n->ticks->last_pos_update_sent = ticks; } } /* send periodic info/einfo */ if (n->state == NS_CONNECTED) { // subtract 10000 to offset this by 10 seconds from *einfo to avoid filling buffers with commands/responses if (td->periodic->info && ticks - (td->periodic->last_info - 10000U) >= td->periodic->info) { int nhere = player_get_phere(td); PLAYER *parray = player_get_parray(td); for (int i = 0; i < nhere; ++i) { if (parray[i].here && td->enter->send_info) { PrivMessage(&parray[i], "*info"); } } td->periodic->last_info = ticks; } if (td->periodic->einfo && ticks - td->periodic->last_einfo >= td->periodic->einfo) { int nhere = player_get_phere(td); PLAYER *parray = player_get_parray(td); for (int i = 0; i < nhere; ++i) { if (parray[i].here && td->enter->send_einfo) { PrivMessage(&parray[i], "*einfo"); } } td->periodic->last_einfo = ticks; } } /* retransmit reliable packets that have not been acked */ rpacket_list_t *l = n->rel_o->queue; rpacket_list_t::iterator iter = l->begin(); while (iter != l->end()) { RPACKET *rp = *iter; if (ticks - rp->ticks > RELIABLE_RETRANSMIT_INTERVAL) { PACKET *p = allocate_packet(rp->len); memcpy(p->data, rp->data, rp->len); /* update packets retransmit tick */ rp->ticks = ticks; queue_packet(p, SP_HIGH); } ++iter; } /* free absent players if its time */ ticks_ms_t flush_check_interval = 60 * 60 * 1000; if (ticks - td->arena->ticks->last_player_flush > flush_check_interval) { player_free_absent_players(td, flush_check_interval, true); td->arena->ticks->last_player_flush = ticks; } /* write packets generated during loop iteration */ send_outgoing_packets(td); } /* while td->running != 0 */ }
// Handle an incoming OFF message. Default disconnects from server and exits void BaseBot::process_off_message( TokenMessage &incoming_message ) { disconnect_from_server(); m_main_dlg->end_dialog(); }
/******************************************************************************* * The entry point to client. Builds a request packet, and then sends it. The * way the packet is built depends on whether the URI and method have been * specified in the command line arguments. *******************************************************************************/ int main(int argc, char **argv) { int num_bytes; socket_t sockfd; int port = 0; char hostname[MAXHOSTNAMESIZE + 1] = { 0 }; char method[MAXMETHODSIZE + 1] = { 0 }; int pot_number = 0; char additions[400] = { 0 }; char message[80]; char packet[MAXPACKETSIZE + 1] = { 0 }; int i; /*check the arguments*/ printf("\n"); for (i = 1; i < argc; ++i) { if (strcmp(argv[i], "-f") == 0) { ++i; continue; } else if (strcmp(argv[i], "-u") == 0) { process_uri(argv[++i], &pot_number, additions, hostname, &port); continue; } else if (strcmp(argv[i], "-m") == 0) { strcpy(method, argv[++i]); continue; } else { printf("usage: %s [-f \"file\"] | [[-m \"method\"] [- u \"URI\"]]", argv[0]); exit(1); } } if (method[0] == '\0') { get_method(method); } /*allows the user to choose the message for a BREW/POST request*/ if (strcmp(method, "BREW") == 0 || strcmp(method, "POST") == 0) { get_message(message); } else { strcpy(message, "Content-length:0\r\n\r\n"); } if (strstr(message, "start") && additions[0] == '\0') { get_additions(additions); } if (pot_number == 0) { pot_number = get_pot_number(); } if (hostname[0] == '\0') { get_hostname(hostname); } if (port == 0) { get_port(&port); } /*build the packet from the indivdual elements built up to now*/ sprintf(packet, "%s pot-%d HTCPCP/1.0\r\n%s%s", method, pot_number, additions, message); sockfd = connect_to_server(hostname, port); /*send the packet*/ num_bytes = send_message(sockfd, packet); if (num_bytes == 0) { printf("Failed to send message %s", packet); } /*wait for response*/ do { num_bytes = receive_message(sockfd, packet, MAXPACKETSIZE); if (num_bytes != 0) { packet[num_bytes] = '\0'; printf("received: %s\n", packet); } } while (packet[0] == '\0'); disconnect_from_server(sockfd); return 0; }
static PyObject* python_disconnect_from_server(PyObject* self, PyObject* args) { if(PyArg_ParseTuple(args, "") == 0) return NULL; disconnect_from_server(); return Py_BuildValue("i", 0); }
int main(int argc, char *argv[]) { int starting_line = 1; /* line to start editing at */ char command[MAXPATHLEN + 50]; /* emacs command buffer */ char fullpath[MAXPATHLEN + 1]; /* full pathname to file */ char *eval_form = NULL; /* form to evaluate with `-eval' */ char *eval_function = NULL; /* function to evaluate with `-f' */ char *load_library = NULL; /* library to load */ int quick = 0; /* quick edit, don't wait for user to finish */ int batch = 0; /* batch mode */ int view = 0; /* view only. */ int nofiles = 0; int errflg = 0; /* option error */ int s; /* socket / msqid to server */ int connect_type; /* CONN_UNIX, CONN_INTERNET, or * CONN_IPC */ int suppress_windows_system = 0; char *display = NULL; #ifdef INTERNET_DOMAIN_SOCKETS char *hostarg = NULL; /* remote hostname */ char *remotearg; char thishost[HOSTNAMSZ]; /* this hostname */ char remotepath[MAXPATHLEN + 1]; /* remote pathname */ int rflg = 0; /* pathname given on cmdline */ char *portarg; unsigned short port = 0; /* port to server */ #endif /* INTERNET_DOMAIN_SOCKETS */ char *path; /* used indiscriminately */ #ifdef SYSV_IPC struct msgbuf *msgp; /* message */ #endif /* SYSV_IPC */ char *tty = NULL; char buffer[GSERV_BUFSZ + 1]; /* buffer to read pid */ char result[GSERV_BUFSZ + 1]; int i; int sz; size_t msz; #ifdef INTERNET_DOMAIN_SOCKETS memset(remotepath, 0, sizeof(remotepath)); #endif /* INTERNET_DOMAIN_SOCKETS */ progname = strrchr(argv[0], '/'); if (progname) ++progname; else progname = argv[0]; #ifdef USE_TMPDIR tmpdir = getenv("TMPDIR"); #endif if (!tmpdir) tmpdir = "/tmp"; display = getenv("DISPLAY"); if (display) display = my_strdup(display); else suppress_windows_system = 1; for (i = 1; argv[i] && !errflg; i++) { if (*argv[i] != '-') break; else if (*argv[i] == '-' && (*(argv[i] + 1) == '\0' || (*(argv[i] + 1) == '-' && *(argv[i] + 2) == '\0'))) { /* `-' or `--' */ ++i; break; } if (!strcmp(argv[i], "-batch") || !strcmp(argv[i], "--batch")) batch = 1; else if (!strcmp(argv[i], "-eval") || !strcmp(argv[i], "--eval")) { if (!argv[++i]) { fprintf(stderr, "%s: `-eval' must be followed by an argument\n", progname); exit(1); } eval_form = argv[i]; } else if (!strcmp(argv[i], "-display") || !strcmp(argv[i], "--display")) { suppress_windows_system = 0; if (!argv[++i]) { fprintf(stderr, "%s: `-display' must be followed by an argument\n", progname); exit(1); } if (display) free(display); /* no need to strdup. */ display = argv[i]; } else if (!strcmp(argv[i], "-nw")) suppress_windows_system = 1; else { /* Iterate over one-letter options. */ char *p; int over = 0; for (p = argv[i] + 1; *p && !over; p++) { switch (*p) { case 'q': quick = 1; break; case 'v': view = 1; break; case 'f': GET_ARGUMENT(eval_function, "-f"); break; case 'l': GET_ARGUMENT(load_library, "-l"); break; #ifdef INTERNET_DOMAIN_SOCKETS case 'h': GET_ARGUMENT(hostarg, "-h"); break; case 'p': GET_ARGUMENT(portarg, "-p"); port = atoi(portarg); break; case 'r': GET_ARGUMENT(remotearg, "-r"); xstrncpy(remotepath, remotearg, sizeof(remotepath)); remotepath[sizeof(remotepath)-1]='\0'; rflg = 1; break; #endif /* INTERNET_DOMAIN_SOCKETS */ default: errflg = 1; } } /* for */ } /* else */ } /* for */ if (errflg) { fprintf(stderr, #ifdef INTERNET_DOMAIN_SOCKETS "Usage: %s [-nw] [-display display] [-q] [-v] [-l library]\n" " [-batch] [-f function] [-eval form]\n" " [-h host] [-p port] [-r remote-path] [[+line] file] ...\n", #else /* !INTERNET_DOMAIN_SOCKETS */ "Usage: %s [-nw] [-q] [-v] [-l library] [-f function] [-eval form] " "[[+line] path] ...\n", #endif /* !INTERNET_DOMAIN_SOCKETS */ progname); exit(1); } if (batch && argv[i]) { fprintf(stderr, "%s: Cannot specify `-batch' with file names\n", progname); exit(1); } #if defined(INTERNET_DOMAIN_SOCKETS) if (suppress_windows_system && hostarg) { fprintf(stderr, "%s: Remote editing is available only on X\n", progname); exit(1); } #endif *result = '\0'; if (eval_function || eval_form || load_library) { #if defined(INTERNET_DOMAIN_SOCKETS) connect_type = make_connection(hostarg, port, &s); #else connect_type = make_connection(NULL, 0, &s); #endif SNPRINTF(sz, command, sizeof(command), "(gnuserv-eval%s '(progn ", quick ? "-quickly" : ""); send_string(s, command); if (load_library) { send_string(s, "(load-library "); send_string(s, clean_string(load_library)); send_string(s, ") "); } if (eval_form) { send_string(s, eval_form); } if (eval_function) { send_string(s, "("); send_string(s, eval_function); send_string(s, ")"); } send_string(s, "))"); /* disconnect already sends EOT_STR */ #ifdef SYSV_IPC if (connect_type == (int)CONN_IPC) disconnect_from_ipc_server(s, msgp, batch && !quick); #else /* !SYSV_IPC */ if (connect_type != (int)CONN_IPC) disconnect_from_server(s, batch && !quick); #endif /* !SYSV_IPC */ } /* eval_function || eval_form || load_library */ else if (batch) { /* no sexp on the command line, so read it from stdin */ int nb; #if defined(INTERNET_DOMAIN_SOCKETS) connect_type = make_connection(hostarg, port, &s); #else connect_type = make_connection(NULL, 0, &s); #endif SNPRINTF(sz, command, sizeof(command), "(gnuserv-eval%s '(progn ", quick ? "-quickly" : ""); send_string(s, command); while ((nb = read(fileno(stdin), buffer, GSERV_BUFSZ - 1)) > 0) { buffer[nb] = '\0'; send_string(s, buffer); } send_string(s, "))"); /* disconnect already sends EOT_STR */ #ifdef SYSV_IPC if (connect_type == (int)CONN_IPC) disconnect_from_ipc_server(s, msgp, batch && !quick); #else /* !SYSV_IPC */ if (connect_type != (int)CONN_IPC) disconnect_from_server(s, batch && !quick); #endif /* !SYSV_IPC */ } if (!batch) { if (suppress_windows_system) { tty = ttyname(0); if (!tty) { fprintf(stderr, "%s: Not connected to a tty", progname); exit(1); } #if defined(INTERNET_DOMAIN_SOCKETS) connect_type = make_connection(hostarg, port, &s); #else connect_type = make_connection(NULL, 0, &s); #endif send_string(s, "(gnuserv-eval '(emacs-pid))"); send_string(s, EOT_STR); if (read_line(s, buffer) == 0) { fprintf(stderr, "%s: Could not establish Emacs process id\n", progname); exit(1); } /* Don't do disconnect_from_server because we have already read data, and disconnect doesn't do anything else. */ #ifdef SYSV_IPC if (connect_type == (int)CONN_IPC) disconnect_from_ipc_server(s, msgp, FALSE); #endif /* !SYSV_IPC */ emacs_pid = (pid_t) atol(buffer); initialize_signals(); } /* suppress_windows_system */ #if defined(INTERNET_DOMAIN_SOCKETS) connect_type = make_connection(hostarg, port, &s); #else connect_type = make_connection(NULL, 0, &s); #endif #ifdef INTERNET_DOMAIN_SOCKETS if (connect_type == (int)CONN_INTERNET) { char *ptr; gethostname(thishost, HOSTNAMSZ); if (!rflg) { /* attempt to generate a path * to this machine */ if ((ptr = getenv("GNU_NODE")) != NULL) { /* user specified a path */ xstrncpy(remotepath, ptr, sizeof(remotepath)-1); remotepath[sizeof(remotepath)-1]='\0'; } } #if 0 /* This is really bogus... re-enable it if you must have it! */ #if defined (hp9000s300) || defined (hp9000s800) else if (strcmp(thishost, hostarg)) { /* try /net/thishost */ strcpy(remotepath, "/net/"); /* (this fails using internet addresses) */ strcat(remotepath, thishost); } #endif #endif } else { /* same machines, no need for path */ remotepath[0] = '\0'; /* default is the empty path */ } #endif /* INTERNET_DOMAIN_SOCKETS */ #ifdef SYSV_IPC if ((msgp = (struct msgbuf *) malloc(sizeof *msgp + GSERV_BUFSZ)) == NULL) { fprintf(stderr, "%s: not enough memory for message buffer\n", progname); exit(1); } /* if */ msgp->mtext[0] = '\0'; /* ready for later strcats */ #endif /* SYSV_IPC */ if (suppress_windows_system) { char *term = getenv("TERM"); pid_t pid = getpid(); if (!term) { fprintf(stderr, "%s: unknown terminal type\n", progname); exit(1); } SNPRINTF(sz, command, sizeof(command), "(gnuserv-edit-files '(tty %s %s %d) '(", clean_string(tty), clean_string(term), (int)pid); } else { /* !suppress_windows_system */ if (0) ; #ifdef HAVE_X_WINDOWS else if (display) { SNPRINTF(sz, command, sizeof(command), "(gnuserv-edit-files '(x %s) '(", clean_string(display)); } #endif } /* !suppress_windows_system */ send_string(s, command); if (!argv[i]) nofiles = 1; for (; argv[i]; i++) { if (i < argc - 1 && *argv[i] == '+') { starting_line = atoi(argv[i++]); } else { starting_line = 1; } /* If the last argument is +something, treat it as a file. */ if (i == argc) { starting_line = 1; --i; } filename_expand(fullpath, argv[i], sizeof(fullpath)); #ifdef INTERNET_DOMAIN_SOCKETS msz = strlen(remotepath) + strlen(fullpath) + 1; path = (char*)malloc(msz); SNPRINTF(sz, path, msz, "%s%s", remotepath, fullpath); #else /* !INTERNET_DOMAIN_SOCKETS */ path = my_strdup(fullpath); #endif /* INTERNET_DOMAIN_SOCKETS */ SNPRINTF(sz, command, sizeof(command), "(%d . %s)", starting_line, clean_string(path)); send_string(s, command); free(path); } SNPRINTF(sz, command, sizeof(command), ")%s%s", (quick || (nofiles && !suppress_windows_system)) ? " 'quick" : "", view ? " 'view" : ""); send_string(s, command); send_string(s, ")"); #ifdef SYSV_IPC if (connect_type == (int)CONN_IPC) disconnect_from_ipc_server(s, msgp, FALSE); #else /* !SYSV_IPC */ if (connect_type != (int)CONN_IPC) disconnect_from_server(s, FALSE); #endif /* !SYSV_IPC */ } /* not batch */ return 0; }
/**************************************************************************** Called when the ggz socket has data pending. ****************************************************************************/ void input_from_ggz(int socket) { if (ggzmod_dispatch(ggzmod) < 0) { disconnect_from_server(); } }
// usage: smp <IP address to connect to> int main( int argc, char** argv ) { if ( argc != 2 ) /* argc should be 2 for correct execution */ { printf( "usage:\n\tsmp <ipaddress>\n\tsmp server\n" ); return EXIT_FAILURE; } int bServerMode = strstr( "server", argv[ 1 ] ) != 0; setup(); unsigned char holder[ BUFFER_SIZE ]; memset( holder, 0x00, BUFFER_SIZE ); if ( !bServerMode ) { // we are talking to the server at ip address argv[ 1 ] char input_string[ 256 ]; printf( "Enter a shared secret: " ); readLine( input_string, 256 ); // TESTCODE: strcpy( input_string, "testme" ); secret = binEncode( input_string, strlen( input_string ) ); /*****************************************************/ /*****************************************************/ /* Do Step 1 and send to other side */ /*****************************************************/ /*****************************************************/ int len = step1( holder, BUFFER_SIZE ); int serverfd = connect_to_server( argv[ 1 ] ); if ( serverfd == 1 ) return EXIT_FAILURE; write_to_server( serverfd, holder, len ); // dumpBuff( holder, len ); /*****************************************************/ /*****************************************************/ /* Get results from other side. */ /* Other side performed Step 2. */ /*****************************************************/ /*****************************************************/ memset( holder, 0x00, BUFFER_SIZE ); len = revc_from_server( serverfd, holder, BUFFER_SIZE ); // dumpBuff( holder, len ); /*****************************************************/ /*****************************************************/ /* Do Step 3 and send to the other side */ /*****************************************************/ /*****************************************************/ step3( holder, BUFFER_SIZE ); write_to_server( serverfd, holder, len ); /*****************************************************/ /*****************************************************/ /* Get bytes from other side and do Step 5 */ /*****************************************************/ /*****************************************************/ memset( holder, 0x00, BUFFER_SIZE ); len = revc_from_server( serverfd, holder, BUFFER_SIZE ); // dumpBuff( holder, len ); step5( holder, len ); disconnect_from_server( serverfd ); } else // we are in server mode, other side will send us data first { int listenfd = listen_server(); /*if ( listenfd == 1 ) return EXIT_FAILURE; TODO: error checking */ char input_string[ 256 ]; printf( "Enter a shared secret: " ); readLine( input_string, 256 ); // TESTCODE: strcpy( input_string, "testme" ); secret = binEncode( input_string, strlen( input_string ) ); int len = revc_from_server( listenfd, holder, BUFFER_SIZE ); // dumpBuff( holder, BUFFER_SIZE); /*****************************************************/ /*****************************************************/ /* Do Step 2 and send to other side */ /*****************************************************/ /*****************************************************/ len = step2( holder, BUFFER_SIZE ); write_to_server( listenfd, holder, len ); len = revc_from_server( listenfd, holder, BUFFER_SIZE ); // dumpBuff( holder, len ); /*****************************************************/ /*****************************************************/ /* Do Step 4 and send to other side */ /*****************************************************/ /*****************************************************/ len = step4( holder, BUFFER_SIZE ); write_to_server( listenfd, holder, len ); disconnect_from_server( listenfd ); } if ( match == 1 ) printf( "Secrets match\n" ); else printf( "Secrets do not match\n"); cleanup(); return EXIT_SUCCESS; }
/** * @brief 发送数据 * @param p_data 待发送的数据 * @param data_len 待发送的数据的长度 * @return 0success -1failed */ int c_net_client_impl::send_data(char *p_data, int data_len) { if(!m_inited) { return -1; } if(NULL == p_data || data_len < 0) { return -1; } if(m_sock_fd < 0) { if(connect_to_server(m_timeout) < 0) { ERROR_LOG("can not connect to server now."); return -1; } } if(m_send_buffer_len > 0) {/**< 发送缓冲中尚有数据,需首先将本次数据添加到发送缓冲中,然后再调用发送函数*/ if(data_len > 0) { append_data_to_send_buffer(p_data, data_len); } int bytes_sent = send_to_server(m_sock_fd, m_send_buffer, m_send_buffer_len); if(bytes_sent > 0) { remove_data_from_send_buffer(bytes_sent); } else if(bytes_sent < 0) {/**< 连接遇到问题,关闭连接*/ disconnect_from_server(); return -1; } else { /**< 无法发送数据 nothing to do*/ } } else {/**< 发送缓冲为空,直接调用发送函数*/ if(data_len > 0) { int bytes_sent = send_to_server(m_sock_fd, p_data, data_len); if(bytes_sent >= 0) { if(bytes_sent < data_len) { append_data_to_send_buffer(p_data + bytes_sent, data_len -bytes_sent); } } else { disconnect_from_server(); return -1; } } else { //nothing to do } } return 0; }