void client_main(CLI *c) {
s_log(LOG_DEBUG, "Service [%s] started", c->opt->servname);
if(c->opt->option.program && c->opt->option.remote) {
/* exec and connect options specified together
* -> spawn a local program instead of stdio */
for(;;) {
SERVICE_OPTIONS *opt=c->opt;
memset(c, 0, sizeof(CLI)); /* connect_local needs clean c */
c->opt=opt;
if(!setjmp(c->err))
c->local_rfd.fd=c->local_wfd.fd=connect_local(c);
else
break;
client_run(c);
if(!c->opt->option.retry)
break;
sleep(1); /* FIXME: not a good idea in ucontext threading */
str_stats();
if(service_options.next) /* don't str_cleanup in inetd mode */
str_cleanup();
}
} else
client_run(c);
str_free(c);
}
int main(int argc, char* argv[]) {
EchoApp_Echo echo_service = CORBA_OBJECT_NIL;
CosNaming_NamingContext name_service = CORBA_OBJECT_NIL;
gchar *id[] = {"EchoApp", "Echo", NULL};
CORBA_Environment ev[1];
CORBA_exception_init(ev);
client_init(&argc, argv, &global_orb, ev);
etk_abort_if_exception(ev, "init failed");
g_print("Resolving service reference from name-service with id\"%s\"\n", id[0]);
name_service = etk_get_name_service(global_orb, ev);
etk_abort_if_exception(ev, "failed resolving name-service");
echo_service = (EchoApp_Echo)etk_name_service_resolve(name_service, id, ev);
etk_abort_if_exception(ev, "failed resolving name service at name-service");
client_run(echo_service, ev);
etk_abort_if_exception(ev, "service not reachable");
client_cleanup(global_orb, echo_service, ev);
etk_abort_if_exception(ev, "cleanup failed");
exit(0);
}
/* =============================================================================
* main
* =============================================================================
*/
MAIN(argc, argv)
{
manager_t* managerPtr;
client_t** clients;
TIMER_T start;
TIMER_T stop;
/* Initialization */
parseArgs(argc, (char** const)argv);
SIM_GET_NUM_CPU(global_params[PARAM_CLIENTS]);
managerPtr = initializeManager();
assert(managerPtr != NULL);
clients = initializeClients(managerPtr);
assert(clients != NULL);
long numThread = global_params[PARAM_CLIENTS];
TM_STARTUP(numThread);
P_MEMORY_STARTUP(numThread);
thread_startup(numThread);
/* Run transactions */
printf("Running clients... ");
fflush(stdout);
GOTO_SIM();
TIMER_READ(start);
#ifdef OTM
#pragma omp parallel
{
client_run(clients);
}
#else
thread_start(client_run, (void*)clients);
#endif
TIMER_READ(stop);
GOTO_REAL();
puts("done.");
printf("Time = %0.6lf\n",
TIMER_DIFF_SECONDS(start, stop));
fflush(stdout);
checkTables(managerPtr);
/* Clean up */
printf("Deallocating memory... ");
fflush(stdout);
freeClients(clients);
/*
* TODO: The contents of the manager's table need to be deallocated.
*/
manager_free(managerPtr);
puts("done.");
fflush(stdout);
TM_SHUTDOWN();
P_MEMORY_SHUTDOWN();
thread_shutdown();
MAIN_RETURN(0);
}
static int test_acd(const char *ifname, const char *address) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL, *reply = NULL;
union in_addr_union pa;
struct ether_addr ha;
int ifindex;
assert_se(in_addr_from_string(AF_INET, address, &pa) >= 0);
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_netlink_open(&rtnl) >= 0);
assert_se(sd_netlink_attach_event(rtnl, e, 0) >= 0);
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, 0) >= 0);
assert_se(sd_netlink_message_append_string(m, IFLA_IFNAME, ifname) >= 0);
assert_se(sd_netlink_call(rtnl, m, 0, &reply) >= 0);
assert_se(sd_rtnl_message_link_get_ifindex(reply, &ifindex) >= 0);
assert_se(sd_netlink_message_read_ether_addr(reply, IFLA_ADDRESS, &ha) >= 0);
client_run(ifindex, &pa.in, &ha, e);
return EXIT_SUCCESS;
}
/*
* main
*/
int
main(int argc, char* argv[])
{
CORBA_char filename[] = "account.ref";
CORBA_long amount=0;
Account 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");
if (argc<2) g_error ("usage: %s <amount>", argv[0]);
amount = atoi(argv[1]);
g_print ("Reading service reference from file \"%s\"\n", filename);
service = (Account) etk_import_object_from_file (global_orb,
filename,
ev);
etk_abort_if_exception(ev, "import service failed");
client_run (service, amount, ev);
etk_abort_if_exception(ev, "service not reachable");
client_cleanup (global_orb, service, ev);
etk_abort_if_exception(ev, "cleanup failed");
exit (0);
}
int main(void)
{
tls_client_t client = {0};
const char *gnutls_ver = NULL;
time_t start = 0;
time_t end = 0;
int ret = 0;
int i = 0;
/* initialise signal handling */
set_signal();
coap_log_set_level(COAP_LOG_DEBUG);
gnutls_ver = gnutls_check_version(NULL);
if (gnutls_ver == NULL)
{
coap_log_error("Unable to determine GnuTLS version");
return EXIT_FAILURE;
}
coap_log_info("GnuTLS version: %s", gnutls_ver);
ret = tls_init();
if (ret != SOCK_OK)
{
coap_log_error("%s", sock_strerror(ret));
return EXIT_FAILURE;
}
ret = tls_client_create(&client, TRUST_FILE_NAME, CERT_FILE_NAME, KEY_FILE_NAME);
if (ret != SOCK_OK)
{
coap_log_error("%s", sock_strerror(ret));
tls_deinit();
return EXIT_FAILURE;
}
for (i = 0; i < NUM_ITER; i++)
{
start = time(NULL);
ret = client_run(&client);
end = time(NULL);
if (ret != SOCK_OK)
{
coap_log_error("%s", sock_strerror(ret));
tls_client_destroy(&client);
tls_deinit();
return EXIT_FAILURE;
}
coap_log_info("Result: %s", sock_strerror(ret));
coap_log_debug("Time: %d sec", (int)(end - start));
coap_log_debug("Sleeping for %d seconds...", DELAY);
sleep(DELAY);
}
tls_client_destroy(&client);
tls_deinit();
return EXIT_SUCCESS;
}
/* -------------------------------------------------------------------------- *
* Hauptfunktion des Clients *
* -------------------------------------------------------------------------- */
int client_main(int argc, char *argv[])
{
client_init();
client_run();
client_shutdown();
return 0;
}
int main(int argc, char *argv[]) {
_cleanup_event_unref_ sd_event *e = NULL;
log_set_max_level(LOG_DEBUG);
log_parse_environment();
log_open();
assert_se(sd_event_new(&e) >= 0);
if (argc == 1) {
log_info("running PPPoE client against local server");
return test_pppoe_server(e);
} else if (argc == 2) {
log_info("running PPPoE client over '%s'", argv[1]);
return client_run(argv[1], e);
} else {
log_error("This program takes one or no arguments.\n"
"\t %s [<ifname>]", program_invocation_short_name);
return EXIT_FAILURE;
}
}
static int test_pppoe_server(sd_event *e) {
sd_netlink *rtnl;
sd_netlink_message *m;
pid_t pid;
int r, client_ifindex, server_ifindex;
r = unshare(CLONE_NEWNET);
if (r < 0 && errno == EPERM)
return EXIT_TEST_SKIP;
assert_se(r >= 0);
assert_se(sd_netlink_open(&rtnl) >= 0);
assert_se(sd_netlink_attach_event(rtnl, e, 0) >= 0);
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_NEWLINK, 0) >= 0);
assert_se(sd_netlink_message_append_string(m, IFLA_IFNAME, "pppoe-server") >= 0);
assert_se(sd_netlink_message_open_container(m, IFLA_LINKINFO) >= 0);
assert_se(sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, "veth") >= 0);
assert_se(sd_netlink_message_open_container(m, VETH_INFO_PEER) >= 0);
assert_se(sd_netlink_message_append_string(m, IFLA_IFNAME, "pppoe-client") >= 0);
assert_se(sd_netlink_message_close_container(m) >= 0);
assert_se(sd_netlink_message_close_container(m) >= 0);
assert_se(sd_netlink_message_close_container(m) >= 0);
assert_se(sd_netlink_call(rtnl, m, 0, NULL) >= 0);
client_ifindex = (int) if_nametoindex("pppoe-client");
assert_se(client_ifindex > 0);
server_ifindex = (int) if_nametoindex("pppoe-server");
assert_se(server_ifindex > 0);
m = sd_netlink_message_unref(m);
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_SETLINK, client_ifindex) >= 0);
assert_se(sd_rtnl_message_link_set_flags(m, IFF_UP, IFF_UP) >= 0);
assert_se(sd_netlink_call(rtnl, m, 0, NULL) >= 0);
m = sd_netlink_message_unref(m);
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_SETLINK, server_ifindex) >= 0);
assert_se(sd_rtnl_message_link_set_flags(m, IFF_UP, IFF_UP) >= 0);
assert_se(sd_netlink_call(rtnl, m, 0, NULL) >= 0);
pid = fork();
assert_se(pid >= 0);
if (pid == 0) {
/* let the client send some discover messages before the server is started */
sleep(2);
/* TODO: manage pppoe-server-options */
execlp("pppoe-server", "pppoe-server", "-F",
"-I", "pppoe-server",
"-C", "Test-AC",
"-S", "Service-Default",
"-S", "Service-First-Auxiliary",
"-S", "Service-Second-Auxiliary",
NULL);
assert_not_reached("failed to execute pppoe-server. not installed?");
}
client_run("pppoe-client", e);
assert_se(kill(pid, SIGTERM) >= 0);
assert_se(wait_for_terminate(pid, NULL) >= 0);
assert_se(!sd_netlink_message_unref(m));
assert_se(!sd_netlink_unref(rtnl));
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int result = ACTION_NONE;
int leave = 0;
char *editor_file = 0;
char path[512];
SDL_Surface *loading;
#ifdef __unix__
gid_t realgid;
hi_dir_chart_file = fopen(HI_DIR "/" CHART_FILE_NAME, "r+");
/* This is where we drop our setuid/setgid privileges.
*/
realgid = getgid();
if (setresgid(-1, realgid, realgid) != 0) {
perror("Could not drop setgid privileges. Aborting.");
exit(1);
}
#endif
/* i18n */
#ifdef ENABLE_NLS
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
#endif
#ifdef _WIN32
/* Get Windows to open files in binary mode instead of default text mode */
_fmode = _O_BINARY;
#endif
/* lbreakout info */
printf( "LBreakout2 %s\nCopyright 2001-2010 Michael Speck\nPublished under GNU GPL\n---\n", VERSION );
printf( "Looking up data in: %s\n", SRC_DIR );
printf( "Looking up highscores in: %s\n", HI_DIR );
printf( "Looking up custom levels in: %s/%s/lbreakout2-levels\n", (getenv( "HOME" )?getenv( "HOME" ):"."), CONFIG_DIR_NAME );
#ifndef AUDIO_ENABLED
printf( "Compiled without sound and music\n" );
#endif
set_random_seed(); /* set random seed */
config_load();
stk_init( SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK );
if ( config.fullscreen )
stk_display_open( SDL_SWSURFACE | SDL_FULLSCREEN, 640, 480, 16 );
else
stk_display_open( SDL_SWSURFACE, 640, 480, 16 );
stk_audio_open( 0,0,0,config.audio_buffer_size );
SDL_WM_SetCaption( "LBreakout2", 0 );
SDL_SetEventFilter( event_filter );
stk_audio_enable_sound( config.sound );
stk_audio_set_sound_volume( config.volume * 16 );
/* load a little loading pic */
stk_surface_set_path( SRC_DIR "/gfx" );
loading = stk_surface_load( SDL_SWSURFACE, "loading.png" );
stk_surface_blit( loading, 0,0,-1,-1, stk_display,
(stk_display->w-loading->w)/2,
(stk_display->h-loading->h)/2 );
stk_display_update( STK_UPDATE_ALL );
/* load the GUI graphics from SRC_DIR/gui_theme */
stk_surface_set_path( SRC_DIR );
stk_audio_set_path( SRC_DIR );
gui_init( "gui_theme" );
stk_surface_set_path( SRC_DIR "/gfx" );
stk_audio_set_path( SRC_DIR "/sounds" );
/* load resources */
/* for simplicity all functions are kept but anything
* that is now themeable is loaded in
* theme_load instead of the original function
* (deleting resources works analouge)
*/
theme_get_list();
if ( config.theme_count != theme_count ) {
if ( config.theme_id >= theme_count )
config.theme_id = 0;
config.theme_count = theme_count;
}
theme_load( theme_names[config.theme_id] );
/* old functions still with initialzations of
* lists or variables
*/
client_game_create();
hint_load_res();
chart_load();
manager_create();
client_create();
exp_load();
editor_create();
help_create();
/* run game */
manager_fade( STK_FADE_IN );
while( !leave && !stk_quit_request ) {
result = manager_run();
switch( result ) {
case ACTION_QUIT: leave = 1; break;
case ACTION_RESUME_0:
manager_fade( STK_FADE_OUT );
if ( client_game_resume_local( 0 ) )
client_game_run();
client_game_finalize();
manager_fade( STK_FADE_IN );
break;
case ACTION_PLAY_LBR:
manager_fade( STK_FADE_OUT );
gameSeed = rand(); /* set random seed for next FREAKOUT/BonusLevels */
if ( client_game_init_local( "LBreakout2" ) )
client_game_run();
client_game_finalize();
manager_fade( STK_FADE_IN );
break;
case ACTION_PLAY_CUSTOM:
manager_fade( STK_FADE_OUT );
gameSeed = rand(); /* set random seed for next FREAKOUT/BonusLevels */
if (gameSeed==0) gameSeed=1; /* not allowed because.... A HACK!!! 0 means to have
no bonus levels to save a parameter */
if ( client_game_init_local( levelset_names_local[config.levelset_id_local] ) )
client_game_run();
client_game_finalize();
manager_fade( STK_FADE_IN );
break;
case ACTION_EDIT:
/* new set? */
if ( strequal( NEW_SET, edit_set ) ) {
editor_file = calloc( 16, sizeof( char ) );
snprintf( path, sizeof(path)-1, "%s/%s/lbreakout2-levels", getenv( "HOME" )? getenv("HOME"):".", CONFIG_DIR_NAME );
if ( !enter_string( font, _("Set Name:"), editor_file, 12 ) || !file_check( path, editor_file, "w" ) ) {
free( editor_file );
break;
}
else
manager_update_set_list();
}
else
editor_file = strdup( edit_set );
if ( editor_init( editor_file ) ) {
manager_fade( STK_FADE_OUT );
editor_run();
editor_clear();
manager_fade( STK_FADE_IN );
}
free( editor_file ); editor_file = 0;
break;
case ACTION_QUICK_HELP:
help_run();
break;
case ACTION_CLIENT:
manager_fade( STK_FADE_OUT );
client_run();
manager_fade( STK_FADE_IN );
break;
default: break;
}
}
manager_fade( STK_FADE_OUT );
/* delete stuff */
help_delete();
manager_delete();
chart_save();
chart_delete();
editor_delete();
exp_delete();
client_game_delete();
hint_delete_res();
theme_delete();
theme_delete_list();
stk_surface_free( &loading );
config_save();
if (hi_dir_chart_file)
fclose(hi_dir_chart_file);
return EXIT_SUCCESS;
}
int start_socket_client(char *host, char *path, int argc, char *argv[])
{
int fd, i;
char *sargs[MAX_ARGS];
int sargc=0;
char line[MAXPATHLEN];
char *p, *user=NULL;
extern int remote_version;
extern int am_sender;
if (*path == '/') {
rprintf(FERROR,"ERROR: The remote path must start with a module name\n");
return -1;
}
p = strchr(host, '@');
if (p) {
user = host;
host = p+1;
*p = 0;
}
if (!user) user = getenv("USER");
if (!user) user = getenv("LOGNAME");
fd = open_socket_out(host, rsync_port);
if (fd == -1) {
exit_cleanup(RERR_SOCKETIO);
}
server_options(sargs,&sargc);
sargs[sargc++] = ".";
if (path && *path)
sargs[sargc++] = path;
sargs[sargc] = NULL;
io_printf(fd,"@RSYNCD: %d\n", PROTOCOL_VERSION);
if (!read_line(fd, line, sizeof(line)-1)) {
return -1;
}
if (sscanf(line,"@RSYNCD: %d", &remote_version) != 1) {
return -1;
}
p = strchr(path,'/');
if (p) *p = 0;
io_printf(fd,"%s\n",path);
if (p) *p = '/';
while (1) {
if (!read_line(fd, line, sizeof(line)-1)) {
return -1;
}
if (strncmp(line,"@RSYNCD: AUTHREQD ",18) == 0) {
auth_client(fd, user, line+18);
continue;
}
if (strcmp(line,"@RSYNCD: OK") == 0) break;
rprintf(FINFO,"%s\n", line);
}
for (i=0;i<sargc;i++) {
io_printf(fd,"%s\n", sargs[i]);
}
io_printf(fd,"\n");
if (remote_version > 17 && !am_sender)
io_start_multiplex_in(fd);
return client_run(fd, fd, -1, argc, argv);
}
void client_main(CLI * c)
{
s_log(LOG_DEBUG, "Service [%s] started", c->opt->servname);
client_run(c);
str_free(c);
}
int main(int argc, char *argv[])
{
int servSock, client_sock;
int port = 8084;
struct sockaddr_in addr;
pid_t pid;
unsigned int process_count = 0;
int reuse_addr = 1;
char *local_ip = NULL;
char *remote_ip = NULL;
char *signal_port_name = NULL;
if (argc > 0) {
local_ip = argv[1];
}
if (argc > 1) {
remote_ip = argv[2];
}
if (argc > 2) {
signal_port_name = argv[3];
}
if (!local_ip) {
local_ip = "127.0.0.1";
}
if (!remote_ip) {
remote_ip = "127.0.0.1";
}
if (signal_port_name) {
port = atoi(signal_port_name);
}
if ((servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
die("Socket Error!\n");
}
setsockopt(servSock, SOL_SOCKET, SO_REUSEADDR, &reuse_addr, sizeof(reuse_addr));
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(port);
if (bind(servSock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
die("Bind Error!\n");
return -1;
}
if (listen(servSock, MAXPENDING) < 0) {
die("Listen error\n");
return -1;
}
for (;;) {
int local_port = use_port++;
int remote_port = use_port++;
if (use_port++ >= PORT_MAX) {
use_port = PORT_MIN;
}
client_sock = client_accept(servSock);
if ((pid = fork()) < 0) {
die("fork() failed");
} else if (pid == 0) {
close(servSock);
client_run(client_sock, local_ip, local_port, remote_ip, remote_port);
exit(0);
}
#if SOCKET2ME_DEBUG
printf("with child process: %d\n", (int) pid);
#endif
close(client_sock);
process_count++;
while (process_count) {
pid = waitpid((pid_t) -1, NULL, WNOHANG);
if (pid < 0) {
die("waitpid() failed");
} else if (pid == 0) {
break;
} else {
process_count--;
}
}
}
}
/**
* Start a client for either type of remote connection. Work out
* whether the arguments request a remote shell or rsyncd connection,
* and call the appropriate connection function, then run_client.
*
* Calls either start_socket_client (for sockets) or do_cmd and
* client_run (for ssh).
**/
static int start_client(int argc, char *argv[])
{
char *p;
char *shell_machine = NULL;
char *shell_path = NULL;
char *shell_user = NULL;
int ret;
pid_t pid;
int f_in,f_out;
int rc;
/* Don't clobber argv[] so that ps(1) can still show the right
* command line. */
if ((rc = copy_argv(argv)))
return rc;
if (!read_batch) { /* for read_batch, NO source is specified */
argc--;
shell_path = check_for_hostspec(argv[0], &shell_machine, &rsync_port);
if (shell_path) { /* source is remote */
argv++;
if (filesfrom_host && *filesfrom_host
&& strcmp(filesfrom_host, shell_machine) != 0) {
rprintf(FERROR,
"--files-from hostname is not the same as the transfer hostname\n");
exit_cleanup(RERR_SYNTAX);
}
if (rsync_port) {
if (!shell_cmd) {
return start_socket_client(shell_machine,
shell_path,
argc, argv);
}
daemon_over_rsh = 1;
}
am_sender = 0;
} else { /* source is local, check dest arg */
am_sender = 1;
if (argc < 1) { /* destination required */
usage(FERROR);
exit_cleanup(RERR_SYNTAX);
}
shell_path = check_for_hostspec(argv[argc], &shell_machine, &rsync_port);
if (shell_path && filesfrom_host && *filesfrom_host
&& strcmp(filesfrom_host, shell_machine) != 0) {
rprintf(FERROR,
"--files-from hostname is not the same as the transfer hostname\n");
exit_cleanup(RERR_SYNTAX);
}
if (!shell_path) { /* no hostspec found, so src & dest are local */
local_server = 1;
if (filesfrom_host) {
rprintf(FERROR,
"--files-from cannot be remote when the transfer is local\n");
exit_cleanup(RERR_SYNTAX);
}
shell_machine = NULL;
shell_path = argv[argc];
} else if (rsync_port) {
if (!shell_cmd) {
return start_socket_client(shell_machine,
shell_path,
argc, argv);
}
daemon_over_rsh = 1;
}
}
} else { /* read_batch */
local_server = 1;
shell_path = argv[argc-1];
if (check_for_hostspec(shell_path, &shell_machine, &rsync_port)) {
rprintf(FERROR, "remote destination is not allowed with --read-batch\n");
exit_cleanup(RERR_SYNTAX);
}
}
if (shell_machine) {
p = strrchr(shell_machine,'@');
if (p) {
*p = 0;
shell_user = shell_machine;
shell_machine = p+1;
}
}
if (verbose > 3) {
rprintf(FINFO,"cmd=%s machine=%s user=%s path=%s\n",
shell_cmd ? safe_fname(shell_cmd) : "",
shell_machine ? safe_fname(shell_machine) : "",
shell_user ? safe_fname(shell_user) : "",
shell_path ? safe_fname(shell_path) : "");
}
/* for remote source, only single dest arg can remain ... */
if (!am_sender && argc > 1) {
usage(FERROR);
exit_cleanup(RERR_SYNTAX);
}
/* ... or no dest at all */
if (!am_sender && argc == 0)
list_only |= 1;
pid = do_cmd(shell_cmd,shell_machine,shell_user,shell_path,
&f_in,&f_out);
/* if we're running an rsync server on the remote host over a
* remote shell command, we need to do the RSYNCD protocol first */
if (daemon_over_rsh) {
int tmpret;
tmpret = start_inband_exchange(shell_user, shell_path,
f_in, f_out, argc);
if (tmpret < 0)
return tmpret;
}
ret = client_run(f_in, f_out, pid, argc, argv);
fflush(stdout);
fflush(stderr);
return ret;
}
