Network module example.
#include <stdio.h>
#include <errno.h>
#define SERVER 0
#define CLIENT 1
int NB_ATTEMPTS= 3 ;
*netw = NULL ;
static pthread_t netw_thr ;
void usage(void)
{
fprintf( stderr, " -v version\n"
" -V log level: LOG_INFO, LOG_NOTICE, LOG_ERR, LOG_DEBUG\n"
" -h help\n"
" -a serveur address name/ip to bind (server mode) (optionnal)\n"
" -s serveur address name/ip to connect (client mode)\n"
" -p port\n"
" -i [v4,v6] ip version (default support both ipv4 and ipv6 )\n" );
}
void process_args( int argc, char **argv, char **address, char **server, char **port, int *nb, int *ip_version )
{
int getoptret = 0,
if( argc == 1 )
{
fprintf( stderr, "No arguments given, help:\n" );
usage();
exit( 1 );
}
while( ( getoptret = getopt( argc, argv, "hvs:V:p:n:i:a:" ) ) != EOF)
{
switch( getoptret )
{
case 'i' :
if( !strcmp( "v4", optarg ) )
{
}
else if( !strcmp( "v6", optarg ) )
{
}
else
{
}
break;
case 'v' :
fprintf( stderr, "Date de compilation : %s a %s.\n", __DATE__, __TIME__ );
exit( 1 );
case 'V' :
if( !strncmp( "LOG_NULL", optarg, 8 ) )
{
}
else
{
if( !strncmp( "LOG_NOTICE", optarg, 10 ) )
{
}
else
{
if( !strncmp( "LOG_INFO", optarg, 8 ) )
{
}
else
{
if( !strncmp( "LOG_ERR", optarg, 7 ) )
{
}
else
{
if( !strncmp( "LOG_DEBUG", optarg, 9 ) )
{
}
else
{
fprintf( stderr, "%s n'est pas un niveau de log valide.\n", optarg );
exit( -1 );
}
}
}
}
}
break;
case 's' :
(*server) = strdup( optarg );
break ;
case 'a' :
(*address) = strdup( optarg );
break ;
case 'n' :
(*nb) = atoi( optarg );
break ;
case 'p' :
(*port) = strdup( optarg );
break ;
default :
case '?' :
{
if( optopt == 'V' )
{
fprintf( stderr, "\n Missing log level\n" );
}
else if( optopt == 'p' )
{
fprintf( stderr, "\n Missing port\n" );
}
else if( optopt != 's' )
{
fprintf( stderr, "\n Unknow missing option %c\n", optopt );
}
usage();
exit( 1 );
}
case 'h' :
{
usage();
exit( 1 );
}
}
}
}
int main(int argc, char **argv)
{
char *addr = NULL ;
char *srv = NULL ;
char *port = NULL ;
process_args( argc, argv, &addr, &srv, &port,&NB_ATTEMPTS, &ip_version );
if( !port )
{
exit( -1 );
}
if( srv && addr )
{
n_log(
LOG_ERR,
"Please specify only one of the following options: -a (server, addr to bind to) or -s (server on which to connect to)" );
}
if( srv )
{
n_log(
LOG_INFO,
"Client mode, connecting to %s:%s", srv, port );
mode = CLIENT ;
}
else
{
n_log(
LOG_INFO,
"Server mode , waiting client on port %s", port );
mode = SERVER ;
}
#ifdef __linux__
struct sigaction sa;
sa.sa_handler = sigchld_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1)
{
perror("sigaction");
exit(1);
}
#endif
if( mode == SERVER )
{
{
n_log(
LOG_ERR,
"Fatal error with network initialization" );
netw_unload();
exit( -1 );
}
int it = 0 ;
for( it = 0 ; it < NB_ATTEMPTS/2 ; it ++ )
{
{
}
else
{
int error = 0 ;
int pthread_error = 0 ;
errno = 0 ;
pthread_error = pthread_create ( &netw_thr, NULL, &
manage_client, (
void *)netw );
error = errno ;
if( pthread_error != 0 )
{
n_log(
LOG_ERR,
"Error creating client management pthread:%d , error: %s", pthread_error, strerror( error ) );
netw_unload();
exit( -1 );
}
pthread_join( netw_thr, NULL );
}
}
int error = 0 ;
while( it < NB_ATTEMPTS )
{
{
{
n_log(
LOG_ERR,
"Error ading client management to thread pool" );
}
it ++ ;
}
else
{
}
}
}
else if( mode == CLIENT )
{
for( int it = 1 ; it <= NB_ATTEMPTS ; it ++ )
{
{
netw_unload();
exit( 1 );
}
N_STR *sended_data = NULL, *recved_data = NULL, *hostname = NULL, *tmpstr = NULL ;
if( tmpstr )
{
n_log(
LOG_NOTICE,
"RECEIVED DATAS: %s - %s", recved_data ->data, hostname ->data );
}
else
{
}
n_log(
LOG_NOTICE,
"Closing client in 5 seconds. See synchronisation on server side..." );
}
}
netw_unload();
exit( 0 );
}
Nilorea Library n_network api test.
void * manage_client(void *ptr)
recv/send datas if any for the client
int get_net_datas(N_STR *str, N_STR **hostname, N_STR **data)
decode data we got from network
int send_net_datas(NETWORK *netw, N_STR *data)
send data to specified network
#define FreeNoLog(__ptr)
Free Handler without log.
#define _str(__PTR)
define true
#define n_log(__LEVEL__,...)
Logging function wrapper to get line and func.
#define LOG_DEBUG
debug-level messages
#define LOG_ERR
error conditions
void set_log_level(const int log_level)
Set the global log level value ( static int LOG_LEVEL )
#define LOG_NOTICE
normal but significant condition
#define LOG_NULL
no log output
#define LOG_INFO
informational
#define free_nstr(__ptr)
free a N_STR structure and set the pointer to NULL
N_STR * char_to_nstr(const char *src)
Convert a char into a N_STR, short version.
A box including a string and his lenght.
void u_sleep(unsigned int usec)
wrapper around usleep for API consistency
N_STR * netw_wait_msg(NETWORK *netw, size_t refresh, size_t timeout)
Wait a message from aimed NETWORK.
#define NETWORK_IPV6
Flag to force IPV6
int netw_make_listening(NETWORK **netw, char *addr, char *port, int nbpending, int ip_version)
Make a NETWORK be a Listening network.
int netw_start_thr_engine(NETWORK *netw)
Start the NETWORK netw Threaded Engine.
#define NETWORK_IPV4
Flag to force IPV4
NETWORK * netw_accept_from_ex(NETWORK *from, int send_list_limit, int recv_list_limit, int non_blocking, int *retval)
make a normal 'accept' .
#define NETWORK_IPALL
Flag for auto detection by OS of ip version to use.
NETWORK * netw_accept_from(NETWORK *from)
make a normal blocking 'accept' .
int netw_close(NETWORK **netw)
Closing a specified Network, destroy queues, free the structure.
int netw_connect(NETWORK **netw, char *host, char *port, int ip_version)
Use this to connect a NETWORK to any listening one, unrestricted send/recv lists.
int destroy_threaded_pool(THREAD_POOL **pool, int delay)
delete a thread_pool, exit the threads and free the structs
int add_threaded_process(THREAD_POOL *thread_pool, void *(*func_ptr)(void *param), void *param, int mode)
add a function and params to a thread pool
int refresh_thread_pool(THREAD_POOL *thread_pool)
try to add some waiting DIRECT_PROCs on some free thread slots, else do nothing
#define DIRECT_PROC
processing mode for added func, direct start
int wait_for_threaded_pool(THREAD_POOL *thread_pool, int delay)
Wait for all the launched process in the thread pool to terminate.
THREAD_POOL * new_thread_pool(int nbmaxthr, int nb_max_waiting)
Create a new pool of nbmaxthr threads.
Structure of a trhead pool.