int get_authenticated_socket( const char * host, int port)
{
int remote = 0 ;
int ret;
dest_host = strdup(host);
dest_port = port;
if (0 < connect_timeout)
set_timeout (connect_timeout);
//if (check_direct(dest_host))
// relay_method = METHOD_DIRECT;
if ( relay_method == METHOD_DIRECT ) {
remote = open_connection (dest_host, dest_port);
if ( remote == SOCKET_ERROR )
g_error( "Unable to connect to destination host, errno=%d\n",
socket_errno());
} else {
remote = open_connection (relay_host, relay_port);
if ( remote == SOCKET_ERROR )
g_error( "Unable to connect to relay host, errno=%d\n",
socket_errno());
}
if (socks_ns.sin_addr.s_addr != 0)
switch_ns (&socks_ns);
switch ( relay_method ) {
case METHOD_HTTP:
ret = begin_http_relay(remote);
switch (ret) {
case START_ERROR:
close (remote);
g_error("failed to begin relaying via HTTP.\n");
case START_OK:
break;
case START_RETRY:
close (remote);
}
break;
case METHOD_DIRECT:
g_debug("Did not using proxy bypass ...(%s,%d)",__FILE__, __LINE__);
break;
}
return remote;
}
void execute (char *cmd, int argc, char *argv[], char* dir, char* classpath)
{
// Set a new signal handler for SIGINT:
if ( signal(SIGINT, terminate) == SIG_ERR )
error("Failed to install new signal handler for SIGINT: %s", error_msg());
// Connect to server:
int socket_fd = open_connection();
// Send request:
send_request(socket_fd, cmd, argc, argv, dir, classpath);
// Fork to handle stdin, stdout and stderr simultaneously:
save_fork();
if ( fork_value == -1 )
error("Fork failed: %s", error_msg());
else if ( fork_value > 0 ) // Parent process; handles stdout and stderr
{
int exit_value = handle_output(socket_fd);
if ( kill(fork_value, SIGINT) == -1 )
error("Stopping child failed: %s", error_msg());
exit(exit_value);
}
else // Child process; handles stdin
{
handle_input(socket_fd);
errno = 0;
if ( close(socket_fd) != 0 )
error("Failed to close socket: %s", error_msg());
}
}
void stop_server_force ()
{
int socket_fd = open_connection();
unsigned char buf[1] = {FORCED_STOP_REQ};
write_chk(socket_fd, buf, 1);
read_cmpl_chk(socket_fd, buf, 1);
}
NMNetlinkMonitor *
nm_netlink_monitor_get (void)
{
static NMNetlinkMonitor *singleton = NULL;
GError *error = NULL;
if (!singleton) {
singleton = (NMNetlinkMonitor *) g_object_new (NM_TYPE_NETLINK_MONITOR, NULL);
g_return_val_if_fail (singleton != NULL, NULL);
if (open_connection (singleton, &error)) {
attach (singleton);
} else {
nm_log_warn (LOGD_HW, "Failed to connect to netlink: (%d) %s",
error ? error->code : 0,
(error && error->message) ? error->message : "(unknown)");
g_clear_error (&error);
g_object_unref (singleton);
singleton = NULL;
}
}
return singleton;
}
int
main(int argc, char **argv)
{
int fd, database_fd, database_size;
krb5_error_code retval;
krb5_context context;
krb5_creds *my_creds;
krb5_auth_context auth_context;
setlocale(LC_ALL, "");
retval = krb5_init_context(&context);
if (retval) {
com_err(argv[0], retval, _("while initializing krb5"));
exit(1);
}
parse_args(argc, argv);
get_tickets(context);
database_fd = open_database(context, file, &database_size);
open_connection(context, slave_host, &fd);
kerberos_authenticate(context, &auth_context, fd, my_principal, &my_creds);
xmit_database(context, auth_context, my_creds, fd, database_fd,
database_size);
update_last_prop_file(slave_host, file);
printf(_("Database propagation to %s: SUCCEEDED\n"), slave_host);
krb5_free_cred_contents(context, my_creds);
close_database(context, database_fd);
exit(0);
}
gboolean
nm_netlink_listener_subscribe (NMNetlinkListener *listener,
int group,
GError **error)
{
NMNetlinkListenerPrivate *priv;
g_return_val_if_fail (NM_IS_NETLINK_LISTENER (listener), FALSE);
priv = NM_NETLINK_LISTENER_GET_PRIVATE (listener);
if (!priv->nlh) {
if (!open_connection (listener, error))
return FALSE;
}
if (nl_socket_add_membership (priv->nlh, group) < 0) {
g_set_error (error, NM_NETLINK_LISTENER_ERROR,
NM_NETLINK_LISTENER_ERROR_NETLINK_JOIN_GROUP,
_("unable to join netlink group: %s"),
nl_geterror ());
return FALSE;
}
return TRUE;
}
int main(int argc, char **argv)
{
signal(SIGINT, interupt_handler);
char uri[MAX_STR_LEN];
char hostname[MAX_STR_LEN];
char identifier[MAX_STR_LEN];
int port;
if (argc != 1) {
strcpy(uri, argv[1]);
} else {
puts("ERROR: SimpClient requires a uri as a arguement.\n");
exit(1);
}
printf("\nOpenning URI: %s\n", uri);
parse_URI(uri, hostname, &port, identifier);
printf("Hostname: %s port: %d identifier: %s\n", hostname, port, identifier);
sockid = open_connection(hostname, port);
printf("Hostname: %s\nport: %d\nidentifier: %s\n", hostname, port, identifier);
perform_http(sockid, hostname, identifier);
return 0;
}
gboolean
nm_netlink_monitor_subscribe (NMNetlinkMonitor *self, int group, GError **error)
{
NMNetlinkMonitorPrivate *priv;
int subs, err;
g_return_val_if_fail (NM_IS_NETLINK_MONITOR (self), FALSE);
priv = NM_NETLINK_MONITOR_GET_PRIVATE (self);
if (!priv->nlh_event) {
if (!open_connection (self, error))
return FALSE;
}
subs = get_subs (self, group) + 1;
if (subs == 1) {
err = nl_socket_add_membership (priv->nlh_event, group);
if (err < 0) {
g_set_error (error, NM_NETLINK_MONITOR_ERROR,
NM_NETLINK_MONITOR_ERROR_NETLINK_JOIN_GROUP,
_("unable to join netlink group: %s"),
nl_geterror (err));
return FALSE;
}
}
/* Update # of subscriptions for this group */
set_subs (self, group, subs);
return TRUE;
}
/*!
Opens a connection to the given address on port REMOTE_LISTEN_PORT, and
sends the broker ticket, provider name and module, MI function name,
context, and object path.
\param addr the provider address.
\param provider the remote provider name.
\param ticket the ticket as issued by the broker.
\param function the MI function call name.
\param ctx the context for this MI call.
\param cop the object path for this call.
\return the connection socket.
*/
static int
__provider_connect(provider_address * addr,
char *provider,
comm_ticket * ticket,
const char *function, CONST CMPIContext * ctx,
CONST CMPIObjectPath * cop)
{
int socket = open_connection(addr->dst_address,
REMOTE_LISTEN_PORT);
char *pnp;
if (socket < 0)
return -1;
if ((pnp = strchr(provider, ':')))
__sft->serialize_string(socket, pnp + 1);
else __sft->serialize_string(socket, provider);
__sft->serialize_string(socket, addr->provider_module);
io_write_fixed_length(socket, ticket, sizeof(comm_ticket));
__sft->serialize_string(socket, function);
socketcomm_serialize_context(socket, __sft, ctx);
__sft->serialize_CMPIObjectPath(socket, cop);
return socket;
}
int main (int argc, char *argv[]) {
struct connection *my_connection;
char test_buf[10];
int port;
char *server_name;
ssize_t r;
printf("Welcome to Battleship!\n");
if (argc != 3) {
show_usage(stderr, argv[0]);
return EXIT_FAILURE;
}
server_name = argv[1];
port = atoi(argv[2]);
my_connection = open_connection(port, server_name);
if (my_connection == NULL) {
fprintf(stderr, "Problem while opening connection on %s:%d\n", server_name, port);
return EXIT_FAILURE;
}
sprintf(test_buf,"NEWGAME\n");
r = send_message(my_connection,test_buf,8);
r = recv_message(my_connection,test_buf,7);
printf("End of Batlleship...\n");
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
const char* udp_port = NULL;
int sockfd = 0;
if (argc != 2)
{
usage();
exit(EXIT_FAILURE);
}
else
udp_port = argv[1];
if ((sockfd = open_connection(udp_port)) == -1)
{
fprintf(stderr, "Error in binding the socket.\n");
exit(EXIT_FAILURE);
}
/* infinite loop to receive data stream */
receive(sockfd);
/* close the socket */
close(sockfd);
return 0;
}
void main(int argc, char **argv)
{
char uri[MAX_STR_LEN];
char hostname[MAX_STR_LEN];
char identifier[MAX_STR_LEN]="";
char ip[100];
int sockid, port;
//printf("Open URI: ");
//scanf("%s", uri);
//printf("Testing Begin...n");
//test for parse
if(parse_URI(argv[1], hostname, &port, identifier) == 0)
{
printf("Errorr in Parasingn ");
exit(1);
}
//get the ip address
if(hostname_to_ip(hostname, ip))
{
printf("Error resolving: %s\n", hostname);
exit(1);
}
printf("port----->%d\n",port);
// gernerate socket id
sockid = open_connection(hostname, port, ip, identifier);
// send and receive message
perform_http(sockid, identifier, hostname);
}
LmHandlerResult harmony_get_device_email_callback(LmMessageHandler* handler, LmConnection *connection, LmMessage *message, gpointer void_harmony) {
char *email;
MP3tunesHarmony *harmony = MP3TUNES_HARMONY(void_harmony);
LmMessageNode *harmony_email_node;
(void)handler;
(void)connection;
harmony_email_node = lm_message_node_get_child(message->node, "email");
if (harmony_email_node) {
email = g_strdup(lm_message_node_get_value(harmony_email_node));
sleep(2); /*
FIXME: This exists because mp3tunes website logins cannot
exceed 1 per second. When a device connects that has been
fully authenticated previously it will rapidly reconnect
three times as it grabs pin, then email, then connects completely.
*/
mp3tunes_harmony_set_email(harmony, email);
g_free(email);
close_connection(harmony);
open_connection(harmony);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
int main(int argc, char *argv[]) {
int server, offset;
int n;
messagedef_t request, response;
event_t event;
eventsel_t eventsel;
void *buf = NULL;
if (argc != 3) {
fprintf(stderr, "USAGE: application <server_ip> <port>\n");
exit(1);
}
/* open the TCP socket */
if ((server = open_connection(argv[1], atoi(argv[2]))) < 0) {
fprintf(stderr, "ERROR; failed to create socket\n");
exit(1);
}
request.version = VERSION;
request.command = GET_EVT;
request.bufsize = 0; // sizeof(eventsel_t);
// eventsel.begevent = 0;
// eventsel.endevent = 2;
fprintf(stderr, "------------------------------\n");
print_request(&request);
write(server, &request, sizeof(messagedef_t));
// write(server, &eventsel, sizeof(eventsel_t));
read(server, &response, sizeof(messagedef_t));
fprintf(stderr, "------------------------------\n");
print_response(&response);
fprintf(stderr, "------------------------------\n");
if (response.command==GET_OK) {
buf = malloc(response.bufsize);
if ((n = bufread(server, buf, response.bufsize)) < response.bufsize) {
fprintf(stderr, "problem reading enough bytes (%d)\n", n);
}
else {
n = 0;
offset = 0;
while (offset<response.bufsize) {
event.def = buf+offset;
event.buf = buf+offset+sizeof(eventdef_t);
fprintf(stderr, "\n");
print_eventdef(event.def);
offset += sizeof(eventdef_t) + event.def->bufsize;
n++;
}
}
FREE(buf);
}
close(server);
exit(0);
}
void ping ()
{
int socket_fd = open_connection();
unsigned char buf[1] = {PING_REQ};
write_chk(socket_fd, buf, 1);
read_cmpl_chk(socket_fd, buf, 1);
printf("Connection ok\n");
}
void caml_debugger_init(void)
{
char * address;
char * port, * p;
struct hostent * host;
int n;
caml_register_global_root(&marshal_flags);
marshal_flags = caml_alloc(2, Tag_cons);
Store_field(marshal_flags, 0, Val_int(1)); /* Marshal.Closures */
Store_field(marshal_flags, 1, Val_emptylist);
address = getenv("CAML_DEBUG_SOCKET");
if (address == NULL) return;
dbg_addr = address;
#ifdef _WIN32
winsock_startup();
(void)atexit(winsock_cleanup);
#endif
/* Parse the address */
port = NULL;
for (p = address; *p != 0; p++) {
if (*p == ':') { *p = 0; port = p+1; break; }
}
if (port == NULL) {
#ifndef _WIN32
/* Unix domain */
sock_domain = PF_UNIX;
sock_addr.s_unix.sun_family = AF_UNIX;
strncpy(sock_addr.s_unix.sun_path, address,
sizeof(sock_addr.s_unix.sun_path));
sock_addr_len =
((char *)&(sock_addr.s_unix.sun_path) - (char *)&(sock_addr.s_unix))
+ strlen(address);
#else
caml_fatal_error("Unix sockets not supported");
#endif
} else {
/* Internet domain */
sock_domain = PF_INET;
for (p = (char *) &sock_addr.s_inet, n = sizeof(sock_addr.s_inet);
n > 0; n--) *p++ = 0;
sock_addr.s_inet.sin_family = AF_INET;
sock_addr.s_inet.sin_addr.s_addr = inet_addr(address);
if (sock_addr.s_inet.sin_addr.s_addr == -1) {
host = gethostbyname(address);
if (host == NULL)
caml_fatal_error_arg("Unknown debugging host %s\n", address);
memmove(&sock_addr.s_inet.sin_addr, host->h_addr, host->h_length);
}
sock_addr.s_inet.sin_port = htons(atoi(port));
sock_addr_len = sizeof(sock_addr.s_inet);
}
open_connection();
caml_debugger_in_use = 1;
caml_trap_barrier = caml_stack_high;
}
void stop_server ()
{
int socket_fd = open_connection();
unsigned char buf[1] = {STOP_REQ};
write_chk(socket_fd, buf, 1);
read_cmpl_chk(socket_fd, buf, 1);
if ( buf[0] == FAILED_RSPCODE )
error("Stop refused by server: Active clients exist\n");
}
int main (int argc, char **argv)
{
if (argc < 2)
usage ("Invalid number of arguments");
{
const char *const action = argv[1];
Success (*function) (Stream, Connection_Id);
Connection_Id conn_id;
char *host;
int port;
if (! strcmp (action, "--version"))
{
printf ("spdsend %s\n", VERSION);
exit (EXIT_OK);
}
if (! strcmp (action, "--open"))
{
if (argc != 4)
usage ("Invalid number of arguments");
host = argv[2];
port = string_to_number (argv[3], 0, 65535);
}
else
{
if (argc != 3)
usage ("Invalid number of arguments");
conn_id = string_to_number (argv[2], CONNECTION_ID_MIN,
CONNECTION_ID_MAX);
if (! strcmp (action, "--close"))
function = close_connection;
else if (! strcmp (action, "--send"))
function = send_command;
else
usage ("Invalid option");
}
{
Stream server = open_server ();
if (server == NONE)
return EXIT_ERROR;
{
int result = (! strcmp (action, "--open")
? open_connection (server, host, port)
: function (server, conn_id));
return (result == OK ? EXIT_OK : EXIT_ERROR);
}
}
}
}
int main( int argc, char* argv[] ) {
char* test_host_1 = "www.reddit.com";
char* test_host_2 = "www.google.com";
char* test_host_3 = "www.bogushostdrsorberlikesturtles.com";
char* google_ip = "130.127.69.75";
int test_port_1 = 80;
int result;
result = open_connection(test_host_1, test_port_1, 0);
fprintf(stderr, "Attempt to connect to %s on %d resulted in: %d\n\n", test_host_1, test_port_1, result);
if( result > 0 )
close(result);
result = open_connection(test_host_2, test_port_1, 0);
fprintf(stderr, "Attempt to connect to %s on %d resulted in: %d\n\n", test_host_2, test_port_1, result);
if( result > 0 )
close(result);
result = open_connection(test_host_3, test_port_1, 0);
fprintf(stderr, "Attempt to connect to %s on %d resulted in: %d\n\n", test_host_3, test_port_1, result);
if( result > 0 )
close(result);
result = open_connection(google_ip, test_port_1, 0);
fprintf(stderr, "Attempt to connect to %s on %d resulted in: %d\n\n", google_ip, test_port_1, result);
if( result > 0 )
close(result);
result = open_connection(google_ip, 0, 2);
fprintf(stderr, "Attempt to connect to %s on default port 8080 resulted in: %d\n\n", google_ip, result);
if( result > 0 )
close(result);
result = bind_socket( 12345, 1 );
fprintf(stderr, "Attempt to connect bind a socket on port 12345 resulted in %d\n\n", result);
if( result > 0 )
close(result);
}
/*
* Before here we've parsed the irrd.conf file, and converted the ci.srcs into
* rps_database_t's. Now, see if there are any files remaining from another transaction.
* And fix up whatever we need to (journal, files, etc)
*/
int init_databases(void){
rps_database_t * temp_db = db_list;
char * s;
/* remove any old files */
remove_update_files();
while(temp_db){
/* check this db has it's own pgp directory */
char db_pgp_dir[strlen(ci.pgp_dir) + strlen(temp_db->name) + 5];
sprintf(db_pgp_dir, "%s/%s", ci.pgp_dir, temp_db->name);
if( (s = dir_chks(db_pgp_dir, 1)) != NULL){
trace(ERROR, default_trace, "init_databases: Directory error: %s\n", s);
fprintf(stderr, "init_databases: A necessary directory gave the following error: %s\n", s);
exit(EXIT_ERROR);
}
serial_from_journal(temp_db); /* load current serial */
if( db_crash(temp_db) ) /* did we crash last time? */
handle_db_crash(temp_db); /* if so, handle it */
/* remove these no matter what*/
remove_db_crash_files(temp_db->name, 0); /* remove all */
remove_db_pgp_copies(temp_db->name);
/* if the DB is trusted and not authoritative (a mirror), and we have the info, open a connection to it */
/* XXX - use the MRT nonblock_connect() instead? */
if( temp_db->trusted && !temp_db->authoritative && temp_db->host && temp_db->port ){
if( !already_connected_to(temp_db->host) ){
struct in_addr addr;
int newsock;
addr.s_addr = temp_db->host;
newsock = open_connection(default_trace, inet_ntoa(addr), temp_db->port);
if(newsock < 0)
trace(NORM, default_trace, "init_databases: Error opening connection to %s(%d)\n",
inet_ntoa(addr), temp_db->port);
else{
rps_connection_t * peer;
if( (peer = rps_select_add_peer(newsock, &mirror_floods)) != NULL){
peer->host = temp_db->host;
peer->db_name = strdup(temp_db->name);
synch_databases(peer, temp_db);
}
trace(NORM, default_trace, "init_database: Opened connection to: %s (%d)\n", inet_ntoa(addr), temp_db->port);
}
}
}
temp_db = temp_db->next;
}
return 1;
}
LmHandlerResult harmony_iq_callback(LmMessageHandler* handler, LmConnection *connection, LmMessage *message, gpointer void_harmony) {
GError *err = NULL;
MP3tunesHarmony *harmony = MP3TUNES_HARMONY(void_harmony);
LmMessageNode *harmony_download_node, *harmony_email_node;
mp3tunes_harmony_download_t *download;
gchar *email;
(void)handler;
harmony_download_node = lm_message_node_get_child(message->node, "download");
if (harmony_download_node) {
mp3tunes_harmony_download_init(&download);
mp3tunes_harmony_download_set_file_key(download, (char*)lm_message_node_get_attribute(harmony_download_node, "fileKey"));
mp3tunes_harmony_download_set_file_name(download, (char*)lm_message_node_get_attribute(harmony_download_node, "fileName"));
mp3tunes_harmony_download_set_file_format(download, (char*)lm_message_node_get_attribute(harmony_download_node, "fileFormat"));
mp3tunes_harmony_download_set_file_size(download, atoi(lm_message_node_get_attribute(harmony_download_node, "fileSize")));
mp3tunes_harmony_download_set_track_title(download, (char*)lm_message_node_get_attribute(harmony_download_node, "trackTitle"));
mp3tunes_harmony_download_set_artist_name(download, (char*)lm_message_node_get_attribute(harmony_download_node, "artistName"));
mp3tunes_harmony_download_set_album_title(download, (char*)lm_message_node_get_attribute(harmony_download_node, "albumTitle"));
mp3tunes_harmony_download_set_device_bitrate(download, (char*)lm_message_node_get_attribute(harmony_download_node, "deviceBitrate"));
mp3tunes_harmony_download_set_file_bitrate(download, (char*)lm_message_node_get_attribute(harmony_download_node, "fileBitrate"));
download_pending_emit(harmony, download);
mp3tunes_harmony_add_download_to_queue(harmony, download);
harmony_success_reply(connection, message, &err);
if (err != NULL) {
error_emit(harmony, MP3TUNES_HARMONY_ERROR_MISC, "Sending success reply failed", err);
}
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
harmony_email_node = lm_message_node_get_child(message->node, "email");
if (harmony_email_node) {
email = g_strdup(lm_message_node_get_value(harmony_email_node));
mp3tunes_harmony_set_email(harmony, email);
g_free(email);
harmony_success_reply(connection, message, &err);
if (err != NULL) {
error_emit(harmony, MP3TUNES_HARMONY_ERROR_MISC, "Sending success reply failed", err);
}
close_connection(harmony);
open_connection(harmony);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
int main(int argc, char **argv)
{
printf("Opening connection\n");
struct scribe_client * c = open_connection("83.212.113.88", 1463);
printf("Sending message\n");
int res = scribe_log(c, "LOGS", "Hello from new C");
printf("Result: %d\n", res);
printf("Closing connection\n");
close_connection(c);
return 0;
}
bool CCam::sendMessage(const char * const data, const size_t length, bool update)
{
/* send_data return false without trying, if no opened connection */
if(update) {
if(!send_data(data, length)) {
if (!open_connection())
return false;
return send_data(data, length);
}
return true;
}
close_connection();
if(!data || !length) {
camask = 1;
return false;
}
if (!open_connection())
return false;
return send_data(data, length);
}
/* connect to the newsserver */
int news_connect( char *news_server )
{
int rc;
if (carrier_detect()>=0) {
ncn=open_connection( news_server, STANDARD_NEWS_PORT, 0); }
if (ncn<0) {
fprintf( log, "open_connection returns %s \n", get_err_text(ncn));
browser->msg_status(0, ncn);
} else {
/* rc = news_send_command( ncn, "mode reader" ); */
rc = news_receive( ncn, "dummy", FALSE ); /* get response from server */
}
return(ncn);
}
gboolean mp3tunes_harmony_connect(MP3tunesHarmony* harmony, GError** err) {
gboolean success = FALSE;
if (harmony->connected) {
return TRUE;
}
success = open_connection(harmony);
if (success == FALSE) {
*err = harmony->error;
mp3tunes_harmony_disconnect(harmony, err);
return success;
}
return success;
}
int main(int argc, char* argv[])
{
if(argc < 3) {
printf("plz input 3 parameters at least!\n");
return 0;
}
int connfd;
connfd = open_connection(atoi(argv[1]), atoi(argv[2]));
if(-1 != connfd) {
send_and_recv_msg_from_srv(connfd);
}
return 0;
}
int
main (int argc, char *argv[])
{
gda_init ();
GdaConnection *cnc;
/* open connections */
cnc = open_connection ();
create_table (cnc);
display_products_contents (cnc);
gda_connection_close (cnc);
return 0;
}
void parent_main_loop(int control_port, unsigned long listen_ip,
int listen_port)
{
Server *serv;
int child;
int control_fd;
/* specify port and size of the listen queue we're going to use */
serv = server_new(listen_ip, listen_port, 1024);
if (listen_port == DONT_CARE)
fprintf(stderr,"Started accepting connections on port %d\n", serv->port);
glob_server = serv;
serv->control_port = control_port;
/* confirm that the control port is valid, since if it isn't, we'll
* have a rather nasty fork-bomb behaviour - children will suicide on
* startup because they can't connect to the control port, the parent
* will notice that there are fewer children than min_children, and
* fork more. */
control_fd = open_connection(serv,inet_addr(control_ip),control_port,1,0);
if (control_fd < 0)
fatal(serv, "parent unable to open control port: %m\n");
else
close(control_fd);
#ifdef DEBUG
fprintf(stderr,"parent pid = %ld\n", getpid());
#endif
glob_child_dat.num_children = 0;
for (child = 0; child < max_children; child++)
glob_child_dat.children[child] = -1;
for (child = 0; child < min_children; child++)
(void) create_child(serv);
signal(SIGCHLD, child_signal);
signal(SIGPIPE, SIG_IGN);
glob_child_dat.curr_child = 0;
/* listen to stdin, so we know when erlang stops */
set_server_read_fd(serv, STDIN_FILENO);
/* tell the first child to start handling connections */
if (debug)
syslog(LOG_INFO,"passing the ball to child %d (# %d)\n",
glob_child_dat.children[glob_child_dat.curr_child],
glob_child_dat.curr_child);
add_data(serv, glob_child_dat.child_pipe[glob_child_dat.curr_child],
"x", 0, 1, fs_output);
server_main_loop(serv, parent_write, parent_read, NULL);
}
bool CBasicClient::send(const unsigned char command, const char* data, const unsigned int size)
{
CBasicMessage::Header msgHead;
msgHead.version = getVersion();
msgHead.cmd = command;
open_connection(); // if the return value is false, the next send_data call will return false, too
if (!send_data((char*)&msgHead, sizeof(msgHead)))
return false;
if (size != 0)
return send_data(data, size);
return true;
}
int start_session(char *server_addr, char *server_port)
{
SSL *ssl;
SSL_CTX *ctx;
open_connection(&ssl, &ctx, server_addr, server_port);
if (do_client_loop(ssl))
SSL_shutdown(ssl);
else
SSL_clear(ssl);
fprintf(stdout, "SSL Connection closed\n");
close_connection(ssl, ctx);
return 0;
}
