#include "skn_common_headers.h"
#include <sys/utsname.h>

Include dependency graph for skn_network_helpers.h:

This graph shows which files directly or indirectly include this file:

Functions
long	skn_get_number_of_cpu_cores ()

int	generate_loadavg_info (char *msg)

int	generate_uname_info (char *msg)

int	generate_datetime_info (char *msg)

double	skn_duration_in_milliseconds (struct timeval pstart, struct timeval pend)

void	skn_program_name_and_description_set (const char name, const char desc)

int	skn_handle_locator_command_line (int argc, char **argv)

int	skn_time_delay (double delay_time)

char *	skn_strip (char *alpha)

uid_t	skn_get_userids ()

void	signals_init ()

void	signals_cleanup (int sig)

int	skn_udp_host_create_broadcast_socket (int port, double rcvTimeout)

int	skn_udp_host_create_regular_socket (int port, double rcvTimeout)

PServiceRequest	skn_service_request_create (PRegistryEntry pre, int host_socket, char *request)

int	skn_udp_service_request (PServiceRequest psr)

int	skn_display_manager_message_consumer_startup (PDisplayManager pdm)

void	skn_display_manager_message_consumer_shutdown (PDisplayManager pdm)

int	get_default_interface_name (char *pchDefaultInterfaceName)

int	get_broadcast_ip_array (PIPBroadcastArray paB)

void	service_registry_entry_response_message_log (const char *response)

void	get_default_interface_name_and_ipv4_address (char intf, char ipv4)

PServiceRegistry	service_registry_valiadated_registry (const char *response)

int	service_registry_valiadate_response_format (const char *response)

int	service_registry_provider (int i_socket, char *response)

PServiceRegistry	service_registry_get_via_udp_broadcast (int i_socket, char *request)

int	service_registry_entry_count (PServiceRegistry psr)

int	service_registry_list_entries (PServiceRegistry psr)

PRegistryEntry	service_registry_find_entry (PServiceRegistry psreg, char *serviceName)

void *	service_registry_get_entry_field_ref (PRegistryEntry prent, char *field)

void	service_registry_destroy (PServiceRegistry psreg)

Variables
sig_atomic_t	gi_exit_flag

char *	gd_pch_message

signed int	gd_i_debug

int	gd_i_socket

char	gd_ch_program_name [SZ_INFO_BUFF]

char	gd_ch_program_desc [SZ_INFO_BUFF]

char *	gd_pch_effective_userid

char	gd_ch_ipAddress [SZ_CHAR_BUFF]

char	gd_ch_intfName [SZ_CHAR_BUFF]

char	gd_ch_hostName [SZ_CHAR_BUFF]

char	gd_ch_hostShortName [SZ_CHAR_BUFF]

int	gd_i_display

int	gd_i_unique_registry

int	gd_i_update

char *	gd_pch_service_name

int	gd_i_i2c_address

Function Documentation

int generate_datetime_info ( char * msg )

Definition at line 78 of file skn_network_helpers.c.

References SZ_INFO_BUFF, and TZ_ADJUST.

Referenced by main(), and skn_display_manager_do_work().

                                       {
     int mLen = 0;
     struct tm *t;
     time_t tim;
 
     tim = time(NULL);
     t = localtime(&tim);
 
     mLen = snprintf(msg, SZ_INFO_BUFF -1, "%02d:%02d:%04d %02d:%02d:%02d",
                     t->tm_mon + 1, t->tm_mday, t->tm_year + 1900,
                     ((t->tm_hour - TZ_ADJUST) < 0 ? (t->tm_hour - TZ_ADJUST + 12) : (t->tm_hour - TZ_ADJUST)), t->tm_min, t->tm_sec);
 
     return mLen;
 }

Here is the caller graph for this function:

int generate_loadavg_info ( char * msg )

Definition at line 45 of file skn_network_helpers.c.

References PLATFORM_ERROR, and SZ_INFO_BUFF.

Referenced by main(), and skn_display_manager_do_work().

                                      {
     double loadavg[4];
     int rc = 0;
 
     rc = getloadavg(loadavg, 3);
 
     if (rc != PLATFORM_ERROR) {
         snprintf(msg, SZ_INFO_BUFF -1, "LoadAvg: 1m=%2.1f, 5m=%2.1f, 15m=%2.1F",
                  loadavg[0], loadavg[1], loadavg[2]);
     } else {
         snprintf(msg, SZ_INFO_BUFF -1, "Load Average: Not Available  %d:%d:%s",
                  rc, errno, strerror(errno));
     }
 
     return rc;
 }

Here is the caller graph for this function:

int generate_uname_info ( char * msg )

Definition at line 62 of file skn_network_helpers.c.

References skn_get_number_of_cpu_cores(), and SZ_INFO_BUFF.

Referenced by main(), and skn_display_manager_do_work().

                                    {
     struct utsname info;
 
     int mLen = 0;
     char * message = "uname() api failed.";
 
     if (uname(&info) != 0) {
         mLen = snprintf(msg, SZ_INFO_BUFF -1, "%s", message);
     } else {
         mLen = snprintf(msg, SZ_INFO_BUFF -1, "%s %s, %s %s | Cores=%ld",
                         info.sysname, info.release, info.version, info.machine,
                         skn_get_number_of_cpu_cores());
     }
     return mLen;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int get_broadcast_ip_array ( PIPBroadcastArray paB )

Collect IP and Broadcast Addresses for this machine

Affects the PIPBroadcastArray
Return -1 on error, or count of interfaces
contains this ipAddress in paB->ipAddrStr[paB->defaultIndex]

Definition at line 214 of file skn_network_helpers.c.

References ARY_MAX_INTF, _ipBroadcastArray::broadAddrStr, _ipBroadcastArray::cbName, _ipBroadcastArray::chDefaultIntfName, _ipBroadcastArray::count, _ipBroadcastArray::defaultIndex, get_default_interface_name(), _ipBroadcastArray::ifNameStr, _ipBroadcastArray::ipAddrStr, _ipBroadcastArray::maskAddrStr, PLATFORM_ERROR, SD_ERR, and SZ_CHAR_BUFF.

Referenced by get_default_interface_name_and_ipv4_address(), service_registry_get_via_udp_broadcast(), service_registry_provider(), and skn_display_manager_message_consumer_thread().

                                                   {
     struct ifaddrs * ifap;
     struct ifaddrs * p;
     int rc = 0;
 
     memset(paB, 0, sizeof(IPBroadcastArray));
     paB->count = 0;
     paB->defaultIndex = 0;
     strcpy(paB->cbName, "IPBroadcastArray");
 
     rc = get_default_interface_name(paB->chDefaultIntfName);
     if (rc == EXIT_FAILURE) { // Alternate method for Mac: 'route -n -A inet'
         skn_logger(SD_ERR, "No Default Network Interfaces Found!.");
         paB->chDefaultIntfName[0] = 0;
     }
     rc = getifaddrs(&ifap);
     if (rc != 0) {
         skn_logger(SD_ERR, "No Network Interfaces Found at All ! %d:%d:%s", rc, errno, strerror(errno) );
         return (PLATFORM_ERROR);
     }
     p = ifap;
 
     while (p && paB->count < ARY_MAX_INTF) {
         if (p->ifa_addr != NULL && p->ifa_addr->sa_family == AF_INET && ((p->ifa_flags & IFF_BROADCAST) > 0)) {
 
             inet_ntop(p->ifa_addr->sa_family, &((struct sockaddr_in *) p->ifa_addr)->sin_addr, paB->ipAddrStr[paB->count], (SZ_CHAR_BUFF - 1));
             inet_ntop(p->ifa_addr->sa_family, &((struct sockaddr_in *) p->ifa_netmask)->sin_addr, paB->maskAddrStr[paB->count], (SZ_CHAR_BUFF - 1));
             inet_ntop(p->ifa_addr->sa_family, &((struct sockaddr_in *) p->ifa_broadaddr)->sin_addr, paB->broadAddrStr[paB->count], (SZ_CHAR_BUFF - 1));
 
             strncpy(paB->ifNameStr[paB->count], p->ifa_name, (SZ_CHAR_BUFF -1));
 
             /* Take match as the default */
             if (strcmp(paB->chDefaultIntfName, p->ifa_name) == 0) {
                 paB->defaultIndex = paB->count;
             }
 
             paB->count++;
         }
         p = p->ifa_next;
     } // end while
     freeifaddrs(ifap);
 
     return paB->count;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int get_default_interface_name ( char * pchDefaultInterfaceName )

Retrieves default internet interface name into param

absolute best way to do this, but not supported on Darwin(i.e OSX) return EXIT_SUCCESS or EXIT_FAILURE

[jscott OSX]$ route -n get 0.0.0.0 route to: default destination: default mask: default gateway: 10.21.1.254 interface: en3 flags: <UP,GATEWAY,DONE,STATIC,PRCLONING> recvpipe sendpipe ssthresh rtt,msec rttvar hopcount mtu expire 0 0 0 0 0 0 1500 0

Definition at line 275 of file skn_network_helpers.c.

References SD_ERR, skn_strip(), and SZ_INFO_BUFF.

Referenced by get_broadcast_ip_array().

                                                               {
     FILE *f_route;
     char line[SZ_INFO_BUFF], *dRoute = NULL, *iName = NULL;
 
     f_route = fopen("/proc/net/route", "r");
     if (f_route != NULL) {
         while (fgets(line, SZ_INFO_BUFF - 1, f_route)) {
             iName = strtok(line, "\t");
             dRoute = strtok(NULL, "\t");
 
             if (iName != NULL && dRoute != NULL) {
                 if (strcmp(dRoute, "00000000") == 0) {
                     strncpy(pchDefaultInterfaceName, iName, (SZ_INFO_BUFF - 1));
                     break;
                 }
             }
         }
         fclose(f_route);
 
         return EXIT_SUCCESS;
     }
     skn_logger(SD_ERR, "Opening ProcFs for RouteInfo Failed: %d:%s, Alternate method will be attempted.", errno, strerror(errno));
 
     f_route = popen("route -n get 0.0.0.0", "r"); // for linux 'route -n -A inet', with interface at line_word[7]
     if (f_route != NULL) {
         while (fgets(line, SZ_INFO_BUFF - 1, f_route)) {
             dRoute = strtok(line, ":");
             iName = strtok(NULL, "\n");
             if (strcmp(skn_strip(dRoute), "interface") == 0) {
                 strncpy(pchDefaultInterfaceName, skn_strip(iName), (SZ_INFO_BUFF - 1));
                 break;
             }
         }
         fclose(f_route);
 
         return EXIT_SUCCESS;
     } else {
         skn_logger(SD_ERR, "Alternate method to get RouteInfo Failed: %d:%s", errno, strerror(errno));
         return EXIT_FAILURE;
     }
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void get_default_interface_name_and_ipv4_address	(	char *	intf,
		char *	ipv4
	)

Definition at line 196 of file skn_network_helpers.c.

References _ipBroadcastArray::chDefaultIntfName, _ipBroadcastArray::defaultIndex, get_broadcast_ip_array(), _ipBroadcastArray::ipAddrStr, PLATFORM_ERROR, SD_ERR, and SZ_CHAR_BUFF.

Referenced by main().

                                                                            {
     IPBroadcastArray aB;
 
     if (get_broadcast_ip_array(&aB) != PLATFORM_ERROR) {
         memcpy(intf, aB.chDefaultIntfName, SZ_CHAR_BUFF);
         memcpy(ipv4, aB.ipAddrStr[aB.defaultIndex], SZ_CHAR_BUFF);
     } else {
         skn_logger(SD_ERR, "InterfaceName and Address: unable to access information.");
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void service_registry_destroy ( PServiceRegistry psreg )

service_registry_destroy()

Free each entry, then the Registry itself.

Definition at line 1159 of file skn_network_helpers.c.

References _serviceRegistry::count, and _serviceRegistry::entry.

Referenced by main(), and service_registry_valiadate_response_format().

                                                       {
     int index = 0;
 
     if (psreg == NULL)
         return;
 
     for (index = 0; index < psreg->count; index++) {
         free(psreg->entry[index]);
     }
     free(psreg);
 }

Here is the caller graph for this function:

int service_registry_entry_count ( PServiceRegistry psr )

Returns the number of services in registry

Definition at line 947 of file skn_network_helpers.c.

References _serviceRegistry::count.

Referenced by main().

                                                        {
     return psr->count;
 }

Here is the caller graph for this function:

void service_registry_entry_response_message_log ( const char * response )

service_registry_entry_response_message_log()

Prints each pair of values from a text registry entry

Definition at line 907 of file skn_network_helpers.c.

References SD_NOTICE.

Referenced by main(), and service_registry_provider().

                                                                         {
     char * worker = NULL, *parser = NULL, *base = strdup(response);
     parser = base;
     skn_logger(SD_NOTICE, "Response Message:");
     while (( ((worker = strsep(&parser, "|")) != NULL) ||
           ((worker = strsep(&parser, "%")) != NULL) ||
           ((worker = strsep(&parser, ";")) != NULL)) &&
           (strlen(worker) > 8)) {
         skn_logger(SD_NOTICE, "[%s]", worker);
     }
     free(base);
 }

Here is the caller graph for this function:

PRegistryEntry service_registry_find_entry	(	PServiceRegistry	psreg,
		char *	serviceName
	)

service_registry_find_entry()

Finds an existing entry
Returns EXIT_FAILURE/SUCCESS

Definition at line 926 of file skn_network_helpers.c.

References _serviceRegistry::entry, and _serviceEntry::name.

Referenced by main(), and service_registry_entry_create().

                                                                                       {
     PRegistryEntry prent = NULL;
     int index = 0;
 
     if (psreg == NULL)
         return NULL;
 
     while (index < psreg->count) {
         if (strcmp(serviceName, psreg->entry[index]->name) == 0) {
             prent = psreg->entry[index];
             break;
         }
         index++;
     }
 
     return prent;
 }

Here is the caller graph for this function:

void* service_registry_get_entry_field_ref	(	PRegistryEntry	prent,
		char *	field
	)

service_registry_get_entry_field_ref()

compute the address of each field on demand, from struct
Returns the address offset of the registry field requested

Definition at line 969 of file skn_network_helpers.c.

                                                                                {
     int index = 0;
     void * result = NULL;
     char * names[4] = { "name", "ip", "port", NULL };
     int offsets[4] = { offsetof(RegistryEntry, name),
                        offsetof(RegistryEntry, ip),
                        offsetof(RegistryEntry, port),
                        0
                      };
     for (index = 0; names[index] != NULL; index++) {
         if (strcmp(names[index], field) == 0) {
             result = (void *) prent + offsets[index];
             break;
         }
     }
     return result;
 }

PServiceRegistry service_registry_get_via_udp_broadcast	(	int	i_socket,
		char *	request
	)

service_registry_get_via_udp_broadcast()

Retrieves entries from every service that responds to the broadcast parses and builds a new Registry of all entries, or unique entries.
Returns Populated Registry

Definition at line 1094 of file skn_network_helpers.c.

References _ipBroadcastArray::broadAddrStr, _ipBroadcastArray::chDefaultIntfName, _ipBroadcastArray::count, _ipBroadcastArray::defaultIndex, gd_ch_intfName, gd_ch_ipAddress, get_broadcast_ip_array(), gi_exit_flag, _ipBroadcastArray::ifNameStr, _ipBroadcastArray::ipAddrStr, PLATFORM_ERROR, SD_DEBUG, SD_EMERG, SD_NOTICE, SD_WARNING, service_registry_create(), service_registry_response_parse(), skn_duration_in_milliseconds(), SKN_FIND_RPI_PORT, SKN_RUN_MODE_RUN, SZ_CHAR_BUFF, and SZ_INFO_BUFF.

Referenced by main().

                                                                                      {
     struct sockaddr_in remaddr; /* remote address */
     socklen_t addrlen = sizeof(remaddr); /* length of addresses */
     IPBroadcastArray aB;
     int vIndex = 0;
     char response[SZ_INFO_BUFF];
     char recvHostName[SZ_INFO_BUFF];
     signed int rLen = 0;
     struct timeval start;
 
     memset(response, 0, sizeof(response));
     memset(recvHostName, 0, sizeof(recvHostName));
 
     get_broadcast_ip_array(&aB);
     strncpy(gd_ch_intfName, aB.chDefaultIntfName, SZ_CHAR_BUFF);
     strncpy(gd_ch_ipAddress, aB.ipAddrStr[aB.defaultIndex], SZ_CHAR_BUFF);
 
     skn_logger(SD_NOTICE, "Socket Bound to %s", aB.ipAddrStr[aB.defaultIndex]);
 
     gettimeofday(&start, NULL);
     for (vIndex = 0; vIndex < aB.count; vIndex++) {
         memset(&remaddr, 0, sizeof(remaddr));
         remaddr.sin_family = AF_INET;
         remaddr.sin_addr.s_addr = inet_addr(aB.broadAddrStr[vIndex]);
         remaddr.sin_port = htons(SKN_FIND_RPI_PORT);
 
         if (sendto(i_socket, request, strlen(request), 0, (struct sockaddr *) &remaddr, addrlen) < 0) {
             skn_logger(SD_WARNING, "SendTo() Timed out; Failure code=%d, etext=%s", errno, strerror(errno));
             break;
         }
         skn_logger(SD_NOTICE, "Message Broadcasted on %s:%s:%d", aB.ifNameStr[vIndex], aB.broadAddrStr[vIndex], SKN_FIND_RPI_PORT);
     }
 
     PServiceRegistry psr = service_registry_create();
     skn_logger(SD_DEBUG, "Waiting for all responses\n");
     while (gi_exit_flag == SKN_RUN_MODE_RUN) { // depends on a socket timeout of 5 seconds
 
         rLen = recvfrom(i_socket, response, (SZ_INFO_BUFF - 1), 0, (struct sockaddr *) &remaddr, &addrlen);
         if (rLen == PLATFORM_ERROR) {  // EAGAIN
             break;
         }
         response[rLen] = 0;
 
         rLen = getnameinfo(((struct sockaddr *) &remaddr), sizeof(struct sockaddr_in), recvHostName, (SZ_INFO_BUFF -1), NULL, 0, NI_DGRAM);
         if (rLen != 0) {
             skn_logger(SD_EMERG, "getnameinfo() failed: %s\n", gai_strerror(rLen));
             break;
         }
 
         skn_logger(SD_DEBUG, "Response(%1.3fs) received from %s @ %s:%d",
                         skn_duration_in_milliseconds(&start, NULL),
                         recvHostName,
                         inet_ntoa(remaddr.sin_addr),
                         ntohs(remaddr.sin_port)
                   );
         service_registry_response_parse(psr, response, NULL);
     }
 
     return (psr);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int service_registry_list_entries ( PServiceRegistry psr )

Logs each entry in service registry

Definition at line 954 of file skn_network_helpers.c.

References _serviceRegistry::count, _serviceRegistry::entry, _serviceEntry::ip, _serviceEntry::name, _serviceEntry::port, and SD_INFO.

Referenced by main().

                                                         {
     int index = 0;
 
     skn_logger(" ", "\nServiceRegistry:");
     for (index = 0; index < psr->count; index++) {
         skn_logger(SD_INFO, "RegistryEntry(%02d) name=%s, ip=%s, port=%d", index, psr->entry[index]->name, psr->entry[index]->ip, psr->entry[index]->port);
     }
     return index;
 }

Here is the caller graph for this function:

int service_registry_provider	(	int	i_socket,
		char *	response
	)

Definition at line 692 of file skn_network_helpers.c.

References _ipBroadcastArray::chDefaultIntfName, _ipBroadcastArray::defaultIndex, gd_i_display, gd_pch_service_name, get_broadcast_ip_array(), gi_exit_flag, _ipBroadcastArray::ipAddrStr, PLATFORM_ERROR, SD_DEBUG, SD_EMERG, SD_ERR, SD_NOTICE, service_registry_entry_response_message_log(), service_registry_valiadate_response_format(), SKN_FIND_RPI_PORT, SKN_RPI_DISPLAY_SERVICE_PORT, SKN_RUN_MODE_RUN, SZ_COMM_BUFF, and SZ_INFO_BUFF.

Referenced by main().

                                                             {
     struct sockaddr_in remaddr; /* remote address */
     socklen_t addrlen = sizeof(remaddr); /* length of addresses */
     IPBroadcastArray aB;
     char request[SZ_INFO_BUFF];
     char recvHostName[SZ_INFO_BUFF];
     signed int rLen = 0, rc = 0;
     int exit_code = EXIT_SUCCESS, i_response_len = 0;
 
 
     memset(request, 0, sizeof(request));
     memset(recvHostName, 0, sizeof(recvHostName));
 
     rc = get_broadcast_ip_array(&aB);
     if (rc == PLATFORM_ERROR) {
         return EXIT_FAILURE;
     }
 
     if (gd_pch_service_name == NULL) {
         gd_pch_service_name = "lcd_display_service";
     }
 
     if (strlen(response) < 16) {
         if (gd_i_display) {
             i_response_len = snprintf(response, (SZ_INFO_BUFF - 1),
                      "name=rpi_locator_service,ip=%s,port=%d|"
                      "name=%s,ip=%s,port=%d|",
                      aB.ipAddrStr[aB.defaultIndex], SKN_FIND_RPI_PORT,
                      gd_pch_service_name,
                      aB.ipAddrStr[aB.defaultIndex], SKN_RPI_DISPLAY_SERVICE_PORT);
         } else {
             i_response_len = snprintf(response, (SZ_INFO_BUFF - 1),
                             "name=rpi_locator_service,ip=%s,port=%d|",
                             aB.ipAddrStr[aB.defaultIndex], SKN_FIND_RPI_PORT);
         }
     }
     service_registry_entry_response_message_log(response);
 
     skn_logger(SD_DEBUG, "Socket Bound to %s:%s", aB.chDefaultIntfName, aB.ipAddrStr[aB.defaultIndex]);
 
     while (gi_exit_flag == SKN_RUN_MODE_RUN) {
         memset(&remaddr, 0, sizeof(remaddr));
         remaddr.sin_family = AF_INET;
         remaddr.sin_port = htons(SKN_FIND_RPI_PORT);
         remaddr.sin_addr.s_addr = htonl(INADDR_ANY);
         addrlen = sizeof(remaddr);
 
         if ((rLen = recvfrom(i_socket, request, (SZ_INFO_BUFF - 1), 0, (struct sockaddr *) &remaddr, &addrlen)) < 0) {
             if (errno == EAGAIN) {
                 continue;
             }
             skn_logger(SD_ERR, "RcvFrom() Failure code=%d, etext=%s", errno, strerror(errno));
             exit_code = EXIT_FAILURE;
             break;
         }
         request[rLen] = 0;
 
         rc = getnameinfo(((struct sockaddr *) &remaddr), sizeof(struct sockaddr_in), recvHostName, (SZ_INFO_BUFF-1), NULL, 0, NI_DGRAM);
         if (rc != 0) {
             skn_logger(SD_ERR, "GetNameInfo() Failure code=%d, etext=%s", errno, strerror(errno));
             exit_code = EXIT_FAILURE;
             break;
         }
         skn_logger(SD_NOTICE, "Received request from %s @ %s:%d", recvHostName, inet_ntoa(remaddr.sin_addr), ntohs(remaddr.sin_port));
         skn_logger(SD_NOTICE, "Request data: [%s]\n", request);
 
         /*
          * Add new registry entry by command */
         if ((strncmp("ADD ", request, sizeof("ADD")) == 0) &&
             (service_registry_valiadate_response_format(&request[4]) == EXIT_SUCCESS)) {
             if ((response[i_response_len-1] == '|') ||
                 (response[i_response_len-1] == '%') ||
                 (response[i_response_len-1] == ';')) {
                 strncpy(&response[i_response_len], &request[4], ((SZ_COMM_BUFF - 1) - (strlen(response) + strlen(&request[4]))) );
                 i_response_len += (rLen - 4);
                 skn_logger(SD_NOTICE, "COMMAND: Add New RegistryEntry Request Accepted!");
             }
         }
 
         if (sendto(i_socket, response, strlen(response), 0, (struct sockaddr *) &remaddr, addrlen) < 0) {
             skn_logger(SD_EMERG, "SendTo() Failure code=%d, etext=%s", errno, strerror(errno));
             exit_code = EXIT_FAILURE;
             break;
         }
 
         /*
          * Shutdown by command */
         if (strcmp("QUIT!", request) == 0) {
             skn_logger(SD_NOTICE, "COMMAND: Shutdown Requested! exit code=%d", gi_exit_flag);
             break;
         }
     }
 
     return exit_code;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int service_registry_valiadate_response_format ( const char * response )

service_registry_valiadate_response_format()

Validates a text registry entry format
Returns EXIT_FAILURE/SUCCESS

Definition at line 869 of file skn_network_helpers.c.

References service_registry_create(), service_registry_destroy(), and service_registry_response_parse().

Referenced by main(), and service_registry_provider().

                                                                      {
     int errors = 0; // false
 
     PServiceRegistry psr = service_registry_create();
     service_registry_response_parse(psr, response, &errors);
     service_registry_destroy(psr);
 
     if (errors > 0) {
         return EXIT_FAILURE; // false
     } else {
         return EXIT_SUCCESS; // true
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PServiceRegistry service_registry_valiadated_registry ( const char * response )

service_registry_valiadated_registry()

Validate the text formatted entry and return registry collection
Returns a Registry with one entry

Definition at line 889 of file skn_network_helpers.c.

References service_registry_create(), and service_registry_response_parse().

                                                                             {
     int errors = 0;
 
     PServiceRegistry psr = service_registry_create();
     service_registry_response_parse(psr, response, &errors);
     if (errors > 0) {
         free(psr);
         return NULL; // false
     }
 
     return psr;
 }

Here is the call graph for this function:

void signals_cleanup ( int sig )

Definition at line 185 of file skn_network_helpers.c.

References gi_exit_flag, and SKN_RUN_MODE_RUN.

Referenced by main().

                               {
     signal(SIGINT, SIG_DFL);
     signal(SIGQUIT, SIG_DFL);
     signal(SIGTERM, SIG_DFL);
 
     if (gi_exit_flag > SKN_RUN_MODE_RUN) { // exit caused by some interrupt -- otherwise it would be exactly 0
         kill(getpid(), sig);
     }
 }

Here is the caller graph for this function:

void signals_init ( )

Definition at line 179 of file skn_network_helpers.c.

References exit_handler().

Referenced by main().

                     {
     signal(SIGINT, exit_handler);  // Ctrl-C
     signal(SIGQUIT, exit_handler);  // Quit
     signal(SIGTERM, exit_handler);  // Normal kill command
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void skn_display_manager_message_consumer_shutdown ( PDisplayManager pdm )

skn_display_manager_message_consumer(PDisplayManager pdm)

Definition at line 654 of file skn_rpi_helpers.c.

References _DISPLAY_MANAGER::dm_thread, _DISPLAY_MANAGER::i_socket, SD_NOTICE, SD_WARNING, and _DISPLAY_MANAGER::thread_complete.

Referenced by skn_display_manager_do_work().

                                                                         {
     void *trc = NULL;
 
     if (pdm->thread_complete != 0) {
         skn_logger(SD_WARNING, "DisplayManager: Canceling thread.");
         pthread_cancel(pdm->dm_thread);
         sleep(1);
     } else {
         skn_logger(SD_WARNING, "DisplayManager: Thread was already stopped.");
     }
     pthread_join(pdm->dm_thread, &trc);
     close(pdm->i_socket);
     skn_logger(SD_NOTICE, "DisplayManager: Thread ended:(%ld)", (long int) trc);
 }

Here is the caller graph for this function:

int skn_display_manager_message_consumer_startup ( PDisplayManager pdm )

skn_display_manager_message_consumer(PDisplayManager pdm)

returns Socket or EXIT_FAILURE

Definition at line 629 of file skn_rpi_helpers.c.

References _DISPLAY_MANAGER::dm_thread, _DISPLAY_MANAGER::i_socket, SD_EMERG, SD_NOTICE, SD_WARNING, skn_display_manager_message_consumer_thread(), SKN_RPI_DISPLAY_SERVICE_PORT, and skn_udp_host_create_regular_socket().

Referenced by skn_display_manager_do_work().

                                                                       {
     /*
      * Start UDP Listener */
     pdm->i_socket = skn_udp_host_create_regular_socket(SKN_RPI_DISPLAY_SERVICE_PORT, 30.0);
     if (pdm->i_socket == EXIT_FAILURE) {
         skn_logger(SD_EMERG, "DisplayManager: Host Init Failed!");
         return EXIT_FAILURE;
     }
 
     /*
      * Create Thread  */
     int i_thread_rc = pthread_create(&pdm->dm_thread, NULL, skn_display_manager_message_consumer_thread, (void *) pdm);
     if (i_thread_rc == -1) {
         skn_logger(SD_WARNING, "DisplayManager: Create thread failed: %s", strerror(errno));
         close(pdm->i_socket);
         return EXIT_FAILURE;
     }
     sleep(1); // give thread a chance to start
 
     skn_logger(SD_NOTICE, "DisplayManager: Thread startup successful... ");
 
     return pdm->i_socket;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double skn_duration_in_milliseconds	(	struct timeval *	pstart,
		struct timeval *	pend
	)

skn_duration_in_microseconds()

expressed in %1.6us seconds.miroseconds

Definition at line 622 of file skn_network_helpers.c.

Referenced by service_registry_get_via_udp_broadcast(), and skn_udp_service_request().

                                                                                   {
     long secs_used = 0;
     double total_micros_used = 0.0;
     struct timeval end;
 
     if (pend == NULL) {   // calc running duration
         pend = &end;
         gettimeofday(pend, NULL);
     }
 
     secs_used=(pend->tv_sec - pstart->tv_sec); //avoid overflow by subtracting first
     total_micros_used = secs_used * 1000.0; // sec to ms
     total_micros_used += (pend->tv_usec - pstart->tv_usec) / 1000.0; // us to ms
 
     return total_micros_used / 1000.0; // express in seconds.milliseconds
 }

Here is the caller graph for this function:

long skn_get_number_of_cpu_cores ( )

Definition at line 40 of file skn_network_helpers.c.

Referenced by generate_rpi_model_info(), generate_uname_info(), and main().

                                    {
     return sysconf(_SC_NPROCESSORS_ONLN);
 }

Here is the caller graph for this function:

uid_t skn_get_userids ( )

DELAY FOR # uS WITHOUT SLEEPING Ref: http://www.raspberry-projects.com/pi/programming-in-c/timing/clock_gettime-for-acurate-timing

Using delayMicroseconds lets the linux scheduler decide to jump to another process. Using this function avoids letting the scheduler know we are pausing and provides much faster operation if you are needing to use lots of delays.

Fixup incase your building on for OSX, which does not implement clock_gettime()

#ifdef MACH #include <sys/time.h> #define CLOCK_REALTIME 0

  clock_gettime is not implemented on OSX *

int clock_gettime(int clk_id, struct timespec* t) { struct timeval now; int rv = gettimeofday(&now, NULL); if (rv) return rv; t->tv_sec = now.tv_sec; t->tv_nsec = now.tv_usec * 1000; return 0; } #endif

void skn_delay_microseconds (int delay_us) { long int start_time; long int time_difference; struct timespec gettime_now;

clock_gettime(CLOCK_REALTIME, &gettime_now); start_time = gettime_now.tv_nsec; //Get nS value while (1) { clock_gettime(CLOCK_REALTIME, &gettime_now); time_difference = gettime_now.tv_nsec - start_time; if (time_difference < 0) time_difference += 1000000000; //(Rolls over every 1 second) if (time_difference > (delay_us * 1000)) //Delay for # nS break; } } Setup effective and real userid

Definition at line 152 of file skn_network_helpers.c.

References gd_pch_effective_userid.

Referenced by main().

                         {
     uid_t real_user_id = 0;
     uid_t effective_user_id = 0;
     struct passwd *userinfo = NULL;
 
     real_user_id = getuid();
     if (gd_pch_effective_userid != NULL) {
         userinfo = getpwnam(gd_pch_effective_userid);
         effective_user_id = userinfo->pw_uid;
     } else {
         effective_user_id = geteuid();
         userinfo = getpwuid(effective_user_id);
         gd_pch_effective_userid = userinfo->pw_name;
     }
 
     return real_user_id;
 }

Here is the caller graph for this function:

int skn_handle_locator_command_line	(	int	argc,
		char **	argv
	)

Definition at line 373 of file skn_network_helpers.c.

References gd_ch_program_name, gd_i_debug, gd_i_display, gd_i_i2c_address, gd_i_unique_registry, gd_i_update, gd_pch_message, gd_pch_service_name, PACKAGE_VERSION, SD_ERR, SD_WARNING, and skn_locator_print_usage().

Referenced by main().

                                                            {
     int opt = 0;
     int longindex = 0;
     struct option longopts[] = { { "include-display-service", 0, NULL, 's' }, /* set true if present */
                                  { "alt-service-name", 1, NULL, 'a' }, /* set true if present */
                                  { "unique-registry", 0, NULL, 'u' }, /* set true if present */
                                  { "non-stop", 1, NULL, 'n' }, /* required param if */
                                  { "debug", 1, NULL, 'd' }, /* required param if */
                                  { "message", 1, NULL, 'm' }, /* required param if */
                                  { "i2c-address", 1, NULL, 'i' }, /* required param if */
                                  { "version", 0, NULL, 'v' }, /* set true if present */
                                  { "help", 0, NULL, 'h' }, /* set true if present */
                                  { 0, 0, 0, 0 } };
 
     /*
      * Get commandline options
      *  longindex is the current index into longopts
      *  optind is current/last index into argv
      *  optarg is value attached(-d88) or next element(-d 88) of argv
      *  opterr flags a scanning error
      */
     while ((opt = getopt_long(argc, argv, "d:m:n:i:a:usvh", longopts, &longindex)) != -1) {
         switch (opt) {
             case 'u':
                 gd_i_unique_registry = 1;
                 break;
             case 's':
                 gd_i_display = 1;
                 break;
             case 'd':
                 if (optarg) {
                     gd_i_debug = atoi(optarg);
                 } else {
                     skn_logger(SD_WARNING, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind, opterr);
                     return (EXIT_FAILURE);
                 }
                 break;
             case 'm':
                 if (optarg) {
                     gd_pch_message = strdup(optarg);
                 } else {
                     skn_logger(SD_WARNING, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind, opterr);
                     return (EXIT_FAILURE);
                 }
                 break;
             case 'n':
                 if (optarg) {
                     gd_i_update = atoi(optarg);
                 } else {
                     skn_logger(SD_WARNING, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind, opterr);
                     return (EXIT_FAILURE);
                 }
                 break;
             case 'a':
                 if (optarg) {
                     gd_pch_service_name = strdup(optarg);
                 } else {
                     skn_logger(SD_WARNING, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind, opterr);
                     return (EXIT_FAILURE);
                 }
                 break;
             case 'i':
                 if (optarg) {
                     gd_i_i2c_address = atoi(optarg);
                 } else {
                     skn_logger(SD_ERR, "%s: input param was invalid! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind,
                                     opterr);
                     return (EXIT_FAILURE);
                 }
                 break;
             case 'v':
                 skn_logger(SD_WARNING, "\n\tProgram => %s\n\tVersion => %s\n\tSkoona Development\n\t<skoona@gmail.com>\n", gd_ch_program_name, PACKAGE_VERSION);
                 return (EXIT_FAILURE);
                 break;
             case '?':
                 skn_logger(SD_WARNING, "%s: unknown input param! %c[%d:%d:%d]\n", gd_ch_program_name, (char) opt, longindex, optind, opterr);
                 skn_locator_print_usage();
                 return (EXIT_FAILURE);
                 break;
             default: /* help and default */
                 skn_locator_print_usage();
                 return (EXIT_FAILURE);
                 break;
         }
     }
 
     return EXIT_SUCCESS;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void skn_program_name_and_description_set	(	const char *	name,
		const char *	desc
	)

Definition at line 462 of file skn_network_helpers.c.

References gd_ch_hostName, gd_ch_hostShortName, gd_ch_program_desc, gd_ch_program_name, and SZ_CHAR_BUFF.

Referenced by main().

                                                                               {
     char hostName[SZ_CHAR_BUFF];
     char * phostName = hostName;
 
     strncpy(gd_ch_program_name, name, sizeof(gd_ch_program_name) - 1);
     strncpy(gd_ch_program_desc, desc, sizeof(gd_ch_program_desc) - 1);
 
     gethostname(hostName, sizeof(hostName) - 1);
         strncpy(gd_ch_hostName, hostName, sizeof(gd_ch_hostName) - 1);
         strsep(&phostName, ".");
         strncpy(gd_ch_hostShortName, hostName, sizeof(gd_ch_hostShortName) - 1);
 
 }

Here is the caller graph for this function:

PServiceRequest skn_service_request_create	(	PRegistryEntry	pre,
		int	host_socket,
		char *	request
	)

Definition at line 603 of file skn_network_helpers.c.

References _serviceRequest::cbName, _serviceRequest::pre, _serviceRequest::request, _serviceRequest::socket, and SZ_INFO_BUFF.

Referenced by main().

                                                                                                {
     PServiceRequest psr = NULL;
 
     if (pre == NULL) {
         return NULL;
     }
     psr = (PServiceRequest) malloc(sizeof(ServiceRequest));
     memset(psr, 0, sizeof(ServiceRequest));
     strcpy(psr->cbName, "PServiceRequest");
     psr->socket = host_socket;
     psr->pre = pre;
     strncpy(psr->request, request, SZ_INFO_BUFF-1);
     return psr;
 }

Here is the caller graph for this function:

char* skn_strip ( char * alpha )

Remove Trailing and Leading Blanks

caution: pointers from argv are readonly and segfault on 'alpha[end] = 0'

Definition at line 480 of file skn_network_helpers.c.

References SD_NOTICE, and SZ_LINE_BUFF.

Referenced by get_default_interface_name(), service_registry_entry_create_helper(), and service_registry_response_parse().

                                {
     if (alpha == NULL || strlen(alpha) < 1)
         return alpha;
 
     int len = strlen(alpha);
     int end = len - 1;
     int start = 0;
 
     // use isgraph() or !isspace() vs isalnum() to allow ['|' ';' '%']
     while (isgraph(alpha[end]) == 0 && end > 0) { // remove trailing non-alphanumeric chars
         alpha[end--] = 0;
     }
 
     len = strlen(alpha);
     while ((isalnum(alpha[start]) == 0) && start < len) { // find first non-alpha stricter
         start++;
     }
     if (start < len && start > 0) {  // move in place
         end = len - start;
         memmove(&alpha[0], &alpha[start], end);
         alpha[end] = 0;
     }
 
     return alpha;
 }

Here is the caller graph for this function:

int skn_time_delay ( double delay_time )

Traditional Millisecond delay.

Definition at line 96 of file skn_network_helpers.c.

Referenced by skn_display_manager_do_work(), skn_display_manager_message_consumer_thread(), and skn_scroller_scroll_lines().

                                       {
     struct timespec timeout;
     if (delay_time == 0.0 || delay_time == 0) delay_time = 0.001;
     timeout.tv_sec = (time_t) delay_time;  // extract integer only
     timeout.tv_nsec = (long) ((delay_time - timeout.tv_sec) * 1000000000L); // 1e+9
     return nanosleep(&timeout, NULL);
 }

Here is the caller graph for this function:

int skn_udp_host_create_broadcast_socket	(	int	port,
		double	rcvTimeout
	)

skn_udp_host_create_broadcast_socket()

creates a dgram socket with broadcast enabled
returns i_socket | EXIT_FAILURE

Definition at line 568 of file skn_network_helpers.c.

References SD_EMERG, and SD_INFO.

Referenced by main().

                                                                       {
     struct sockaddr_in addr;
     int i_socket, broadcastEnable = 1;
 
     if ((i_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
         skn_logger(SD_EMERG, "Create Socket error=%d, etext=%s", errno, strerror(errno));
         return (EXIT_FAILURE);
     }
     if ((setsockopt(i_socket, SOL_SOCKET, SO_BROADCAST, &broadcastEnable, sizeof(broadcastEnable))) < 0) {
         skn_logger(SD_EMERG, "Set Socket Broadcast Option error=%d, etext=%s", errno, strerror(errno));
         return (EXIT_FAILURE);
     }
 
     struct timeval tv;
     tv.tv_sec = rcvTimeout;
     tv.tv_usec = (long)(rcvTimeout - tv.tv_sec) * 1000000L;
     skn_logger(SD_INFO, "Set Socket RcvTimeout Option set to: tv_sec=%ld, tv_usec=%ld", tv.tv_sec, tv.tv_usec);
     if ((setsockopt(i_socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))) < 0) {
         skn_logger(SD_EMERG, "Set Socket RcvTimeout Option error=%d, etext=%s", errno, strerror(errno));
         return (EXIT_FAILURE);
     }
 
     /* set up local address */
     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(i_socket, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
         skn_logger(SD_EMERG, "Bind to local Socket error=%d, etext=%s", errno, strerror(errno));
         return (EXIT_FAILURE);
     }
 
     return i_socket;
 }

Here is the caller graph for this function:

int skn_udp_host_create_regular_socket	(	int	port,
		double	rcvTimeout
	)

skn_udp_host_create_regular_socket()

creates a dgram socket without broadcast enabled
returns i_socket | EXIT_FAILURE

Definition at line 527 of file skn_network_helpers.c.

References SD_EMERG.

Referenced by main(), and skn_display_manager_message_consumer_startup().

                                                                     {
     struct sockaddr_in addr;
     int i_socket, reuseEnable = 1;
 
     if ((i_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
         skn_logger(SD_EMERG, "Create Socket error=%d, etext=%s", errno, strerror(errno));
         return (EXIT_FAILURE);
     }
 
     if ((setsockopt(i_socket, SOL_SOCKET, SO_REUSEADDR, &reuseEnable, sizeof(reuseEnable))) < 0) {
         skn_logger(SD_EMERG, "Set Socket Reuse Option error=%d, etext=%s", errno, strerror(errno));
         return (EXIT_FAILURE);
     }
 
     struct timeval tv;
     tv.tv_sec = rcvTimeout;
     tv.tv_usec = (long)(rcvTimeout - tv.tv_sec) * 1000000L;
     if ((setsockopt(i_socket, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))) < 0) {
         skn_logger(SD_EMERG, "Set Socket RcvTimeout Option error=%d, etext=%s", errno, strerror(errno));
         return (EXIT_FAILURE);
     }
 
     /* set up local address */
     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(i_socket, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
         skn_logger(SD_EMERG, "Bind to local Socket error=%d, etext=%s", errno, strerror(errno));
         return (EXIT_FAILURE);
     }
 
     return i_socket;
 }

Here is the caller graph for this function:

int skn_udp_service_request ( PServiceRequest psr )

skn_udp_service_request()

side effects: none
returns EXIT_SUCCESS | EXIT_FAILURE

Definition at line 645 of file skn_network_helpers.c.

References _serviceEntry::ip, _serviceEntry::name, PLATFORM_ERROR, _serviceEntry::port, _serviceRequest::pre, _serviceRequest::request, _serviceRequest::response, SD_INFO, SD_NOTICE, SD_WARNING, skn_duration_in_milliseconds(), _serviceRequest::socket, and SZ_INFO_BUFF.

Referenced by main().

                                                  {
     struct sockaddr_in remaddr; /* remote address */
     socklen_t addrlen = sizeof(remaddr); /* length of addresses */
     signed int vIndex = 0;
     struct timeval start, end;
 
     memset(&remaddr, 0, sizeof(remaddr));
     remaddr.sin_family = AF_INET;
     remaddr.sin_addr.s_addr = inet_addr(psr->pre->ip);
     remaddr.sin_port = htons(psr->pre->port);
 
     /*
      * SEND */
     gettimeofday(&start, NULL);
     if (sendto(psr->socket, psr->request, strlen(psr->request), 0, (struct sockaddr *) &remaddr, addrlen) < 0) {
         gettimeofday(&end, NULL);
         skn_logger(SD_WARNING, "ServiceRequest: SendTo(%1.6f) Timed out; Failure code=%d, etext=%s", skn_duration_in_milliseconds(&start,&end), errno, strerror(errno));
         return EXIT_FAILURE;
     }
     skn_logger(SD_NOTICE, "ServiceRequest sent to %s:%s:%d", psr->pre->name, psr->pre->ip, psr->pre->port);
 
     /*
      * RECEIVE */
     vIndex = recvfrom(psr->socket, psr->response, (SZ_INFO_BUFF - 1), 0, (struct sockaddr *) &remaddr, &addrlen);
     if (vIndex == PLATFORM_ERROR) {
         gettimeofday(&end, NULL);
         skn_logger(SD_WARNING, "ServiceRequest: recvfrom(%1.6f) Failure code=%d, etext=%s", skn_duration_in_milliseconds(&start,&end), errno, strerror(errno));
         return EXIT_FAILURE;
     }
     psr->response[vIndex] = 0;
     gettimeofday(&end, NULL);
 
     skn_logger(SD_INFO, "Response(%1.3fs) received from [%s] %s:%d",
                     skn_duration_in_milliseconds(&start,&end),
                     psr->response,
                     inet_ntoa(remaddr.sin_addr),
                     ntohs(remaddr.sin_port)
               );
 
     if (strcmp(psr->response, "QUIT!") == 0) {
         skn_logger(SD_NOTICE, "Shutdown Requested!");
         return EXIT_FAILURE;
     }
 
     return (EXIT_SUCCESS);
 }