wl_logproxy: updated to latest version

Update logproxy service to the latest version.

Signed-off-by: Igal Chernobelsky <igalc@ti.com>

1 files changed, 332 insertions, 129 deletions

diff --git a/wl_logproxy.c b/wl_logproxy.c
index fa82b2f..dee4a4b 100755
--- a/wl_logproxy.c
+++ b/wl_logproxy.c
@@ -1,8 +1,8 @@
 /*
  *
- * Description: Log Proxy for real-time log viewing
- * Author: Gil Barak
- * Date: 15/06/2012
+ * Description: wl Firmware Log Service for off-line and real-time log viewing
+ * Maintainer: gil.barak@ti.com
+ * Last Update: 14/08/2012
  *
  */
 #include <stdio.h>
@@ -16,21 +16,32 @@
 #include <sys/time.h>
 #include <netinet/in.h>
 #include <signal.h>
+#include <errno.h>
 
+
+/* Defines */
 #define INVALID_HANDLE -1
 
-#define BUFFER_SIZE 256
-#define FILE_POLL_INTERVAL 2 // in seconds
-#define KEEP_ALIVE_INTERVAL 5 // in seconds
+#define FILE_NAME "wl_fwlog.log"
+#define FILE_NAME_PREV "wl_fwlog_prev.log"
 
+#define BUFFER_SIZE 1024
+#define FILE_POLL_INTERVAL 60 // in seconds
+#define KEEP_ALIVE_INTERVAL 1 // in seconds
+#define MAX_PATH 256
+#define MAX_FILE_SIZE 100000000 // Max file size is 100mb
+/***********/
 
-int socket_connected = 0;
 
+/* Globals */
+int socket_connected = 0;
+int socket_enabled = 0;
+/***********/
 
 
 void error(const char *msg)
 {
-    printf("FW LOGGER: %s\r\n", msg);
+    printf("FW LOGGER ERROR: %s\r\n", msg);
 }
 
 
@@ -40,152 +51,344 @@ void sigpipe_handler()
         socket_connected = 0;
 }
 
+// ************************************************** //
+//
+// Function name: create_listen_socket
+//
+// Description: Listen on a local port for remote
+//                              client connections
+//
+//
+//
+//
+// ************************************************** //
+int create_listen_socket(int listen_port)
+{
+        struct sockaddr_in serv_addr, cli_addr;
+        int sock_flags = 0;
+        int listen_sock = INVALID_HANDLE;
+
+        if(listen_port == 0)
+        {
+                socket_enabled = 0;
+                return -1;
+        }
+
+        listen_sock = socket(AF_INET, SOCK_STREAM, 0);
+        if (listen_sock == INVALID_HANDLE)
+        {
+                error("opening socket\r\n");
+                exit(1);
+        }
+
+        bzero((char *) &serv_addr, sizeof(serv_addr));
+        serv_addr.sin_family = AF_INET;
+        serv_addr.sin_addr.s_addr = INADDR_ANY;
+        serv_addr.sin_port = htons(listen_port);
+
+        // Bind to local port
+        if (bind(listen_sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
+        {
+                  error("on binding\r\n");
+                  exit(1);
+        }
+
+        listen(listen_sock,1);
+
+        // Set the callback for socket timeout signal handling
+        signal(SIGPIPE,sigpipe_handler);
+
+
+        // Set the listening socket to non-blocking mode
+        sock_flags = fcntl(listen_sock, F_GETFL, 0);
+        fcntl(listen_sock, F_SETFL, sock_flags | O_NONBLOCK);
+
+        return listen_sock;
+}
 
-int main(int argc, char *argv[])
+// ************************************************** //
+//
+// Function Name: accept_client
+//
+// Description:
+//                              Monitor client activity and allow new
+//                              connections if the client is disconnected
+//
+//
+// ************************************************** //
+int accept_client(int listen_sock)
 {
-     int sockfd, newsockfd, portno;
-     socklen_t clilen;
-     char buffer[BUFFER_SIZE + 1] = {0}; // +1 for safety
-     char ka_buff;
-     struct sockaddr_in serv_addr, cli_addr;
-     int n = 0;
-     int sent_bytes = 0;
-     int fp_fwlog = INVALID_HANDLE;
-     struct timeval tv;
+        int client_sock = INVALID_HANDLE;
+        socklen_t clilen;
+        struct sockaddr_in cli_addr;
+        struct timeval tv;
+
+        tv.tv_sec = KEEP_ALIVE_INTERVAL;
+        tv.tv_usec = 0;
+
+        clilen = sizeof(cli_addr);
+        // Non-Blocking accept for remote client connections
+        client_sock = accept(listen_sock, (struct sockaddr *) &cli_addr, &clilen);
+
+        if(client_sock != INVALID_HANDLE)
+        {
+                printf("Client connected!\r\n");
+                if(setsockopt(client_sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)))
+                {
+                        error("failed to set timeout for recv\r\n");
+                        close(client_sock);
+                        close(listen_sock);
+                        exit(EXIT_FAILURE);
+                }
+                socket_connected = 1;
+        }
+
+        return client_sock;
+}
 
+// ************************************************** //
+//
+// Function Name: send_data
+//
+// Description:
+//                              Send the binary logs to the remote
+//                              client that is currently connected
+//
+//
+// ************************************************** //
+void send_data(int client_sock, char *buffer, int buf_size)
+{
+        int sent_bytes = 0;
+        // Send the buffer to the remote client
+         if(socket_connected)
+         {
+                 sent_bytes = 0;
+                 while( buf_size > 0 )
+                 {
+                         sent_bytes = send(client_sock,(char *)(buffer + sent_bytes),buf_size,0);
+                         if (sent_bytes < 0)
+                         {
+                                 printf("Send failed! %d %d\n", buf_size, client_sock);
+                                 close(client_sock);
+                                 socket_connected = 0;
+                                 break;
+                         }
+                         buf_size -= sent_bytes;
+                 }
+         }
+}
 
+// ************************************************** //
+//
+// Function Name: keep_alive
+//
+// Description:
+//                              Verify that the remote client is
+//                              alive by receiving keep alive data
+//
+//
+// ************************************************** //
+void keep_alive(int client_sock)
+{
+        char ka_buff;
+        int n = 0;
+        // Verify keep alive
+         if(socket_connected)
+         {
+                 n = recv(client_sock, &ka_buff, 1, 0);
+                 if (n < 0)
+                 {
+                         error("Client disconnected");
+                         close(client_sock);
+                         socket_connected = 0;
+                 }
+         }
+}
 
-     if (argc < 3) {
-         fprintf(stderr,"Usage: ./logProxy [listen port] [log file path]\n");
-         exit(1);
-     }
+// ************************************************** //
+//
+// Function Name: open_fwlog
+//
+// Description:
+//                              Wait until the fwlog file is created
+//                              and open it for read access
+//
+// Return:
+//                      file handle to fwlog
+//
+// ************************************************** //
+int open_fwlog(int fp_fwlog, char *file_path)
+{
+         if(fp_fwlog == INVALID_HANDLE)
+         {
+                 fp_fwlog = open(file_path, O_RDONLY);
+         }
 
-     sockfd = socket(AF_INET, SOCK_STREAM, 0);
-     if (sockfd < 0) {
-        error("opening socket\r\n");
-        exit(1);
-     }
+         return fp_fwlog;
+}
 
-     bzero((char *) &serv_addr, sizeof(serv_addr));
-     portno = atoi(argv[1]);
-     serv_addr.sin_family = AF_INET;
-     serv_addr.sin_addr.s_addr = INADDR_ANY;
-     serv_addr.sin_port = htons(portno);
-
-     // Bind to local port
-     if (bind(sockfd, (struct sockaddr *) &serv_addr,
-              sizeof(serv_addr)) < 0) {
-              error("on binding\r\n");
-              exit(1);
-     }
+// ************************************************** //
+//
+// Function Name: read_fwlog
+//
+// Description:
+//                              read the binary logs from the fwlog
+//                              into the buffer
+//
+// Return:
+//                      file handle to fwlog
+//
+// ************************************************** //
+int read_fwlog(int fp_fwlog, char *buffer)
+{
+        int n = 0;
+        bzero(buffer,BUFFER_SIZE);
+
+        // Attempt to read logs from the fwlog
+        n = read(fp_fwlog,buffer,BUFFER_SIZE);
+        if (n < 0)
+        {
+                error("reading from file\r\n");
+                return INVALID_HANDLE;
+        }
+        return n;
+}
 
-     listen(sockfd,1);
+void backup_log(int fp_bkplog, char *buffer, int buf_size)
+{
+        int wr_bytes = 0;
+
+        do
+        {
+                wr_bytes = write(fp_bkplog, buffer, buf_size);
+                if(wr_bytes < 0)
+                {
+                        error("writing to backup log!");
+                        exit(EXIT_FAILURE);
+                }
+        }
+        while (wr_bytes < buf_size);
+}
+
+int create_file(char *filename)
+{
+        int fp_bkplog;
+#ifdef ANDROID
+        fp_bkplog = open(filename, O_RDWR|O_TRUNC|O_CREAT, S_IRUSR|S_IWUSR);
+#else
+        fp_bkplog = open(filename, O_RDWR|O_TRUNC|O_CREAT, S_IREAD|S_IWRITE);
+#endif
+
+        if (fp_bkplog == INVALID_HANDLE)
+        {
+                error("Could not open output log file");
+                exit(EXIT_FAILURE);
+        }
+
+        return fp_bkplog;
+}
+// ************************************************** //
+//
+// Function Name: main
+//
+// Description:
+//
+//x
+//
+//
+// ************************************************** //
+int main(int argc, char *argv[])
+{
+     int listen_sock, client_sock = INVALID_HANDLE;
+     char buffer[BUFFER_SIZE + 1] = {0}; // +1 for safety
+     int n = 0, buf_size = 0;
+     int fp_fwlog = INVALID_HANDLE;
+     int fp_bkplog = INVALID_HANDLE;
+     char filename[MAX_PATH + 1] = {0}; // +1 for safety
+     char filename_prev[MAX_PATH + 1] = {0}; // +1 for safety
+     uint max_file_size = MAX_FILE_SIZE;
+     struct stat st;
 
-     signal(SIGPIPE,sigpipe_handler);
 
-     clilen = sizeof(cli_addr);
-     while(1)
+     if (argc < 3)
      {
-                 newsockfd = accept(sockfd,
-                                         (struct sockaddr *) &cli_addr,
-                                         &clilen);
+         fprintf(stderr,"Usage: ./logProxy [listen port] [log file] [backup directory]\n");
+         exit(EXIT_FAILURE);
+     }
 
-                 socket_connected = 1;
+     // Max file size is an optional value
+     if(argc > 4)
+     {
+         max_file_size = atol(argv[4]);
+     }
 
-                 if (newsockfd <= 0) {
-                          error("accept\r\n");
-                          close(sockfd);
-                          exit(1);
-                 }
+     listen_sock = create_listen_socket(atoi(argv[1]));
 
-                 printf("Client connected!\r\n");
+     //
+     // If we arrive here the listen socket was created successfully, otherwise we would have exited the process
+     //
 
-                 bzero(buffer,BUFFER_SIZE);
+     // Create the backup file names
+     strncpy(filename,argv[3], MAX_PATH - sizeof(FILE_NAME));
+     strncpy(filename_prev,argv[3], MAX_PATH - sizeof(FILE_NAME));
+     strcat(filename, FILE_NAME);
+     strcat(filename_prev, FILE_NAME_PREV);
 
-                 tv.tv_sec = KEEP_ALIVE_INTERVAL;
-                 tv.tv_usec = 0;
-                 if(setsockopt(newsockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv))) {
-                         error("failed to set timeout for recv\r\n");
-                         close(newsockfd);
-                         close(sockfd);
-                         exit(1);
-                 }
+     fp_bkplog = create_file(filename);
 
+     // Main Loop
+     while(1)
+     {
+         // Check on the client connection status
+         if (   (socket_enabled == 1) &&
+                        (client_sock == INVALID_HANDLE || socket_connected == 0) )
+         {
+                 client_sock = accept_client(listen_sock);
+         }
+
+         if(fp_fwlog != INVALID_HANDLE)
+         {
+                         // Read the fwlog sysfs file - This is a blocking function
+                         buf_size = read_fwlog(fp_fwlog, buffer);
+
+                         if(buf_size == INVALID_HANDLE)
+                         {
+                                 error("driver unloaded: fwlog has been removed");
+                                 fp_fwlog = INVALID_HANDLE;
+                                 continue;
+                         }
 
-                 // attempt to read the log file every 5 seconds
-                 // this is done in case the driver is down and the file is removed
-                 do
-                 {
-                         if(!socket_connected) {
-                                 error("socket not connected anymore\r\n");
-                                 break;
+                         // Create a new file if the log file exceeds the max size
+                         stat(filename, &st);
+                         if(st.st_size >= max_file_size)
+                         {
+                                 close(fp_bkplog);
+                                 rename(filename, filename_prev);
+                                 fp_bkplog = create_file(filename);
                          }
 
-                         n = recv(newsockfd, &ka_buff, 1, 0);
+                         // keep alive
+                         keep_alive(client_sock);
 
-                         if (n < 0) {
-                                 error("keep alive timeout\r\n");
-                                 socket_connected = 0;
-                                 close(newsockfd);
-                                 if(fp_fwlog != INVALID_HANDLE) {
-                                         close(fp_fwlog);
-                                         fp_fwlog = INVALID_HANDLE;
-                                 }
-                                 break;
+                         if(buf_size > 0)
+                         {
+                                 // write the log data into the backup file
+                                 backup_log(fp_bkplog, buffer, buf_size);
+
+                                 // Try to send the logs to the remote client
+                                 send_data(client_sock, buffer, buf_size);
                          }
 
-                         fp_fwlog = open(argv[2], O_RDONLY);
-                         sleep(FILE_POLL_INTERVAL);
 
-                 } while(fp_fwlog <= 0);
+         }
+         else
+         {
+                 // To prevent high io/cpu usage sleep between attempts
+                 sleep(FILE_POLL_INTERVAL);
+                 // Try to open the fwlog file
+                 fp_fwlog = open_fwlog(fp_fwlog, argv[2]);
+         }
 
-                 if(socket_connected)
-                 {
-                         do
-                         {
-                                 if(!socket_connected) {
-                                         error("socket not connected anymore\r\n");
-                                         break;
-                                 }
-
-                                 n = read(fp_fwlog,&buffer,BUFFER_SIZE);
-                                 if (n < 0) {
-                                         error("reading from file\r\n");
-                                         if(fp_fwlog != INVALID_HANDLE) {
-                                                 close(fp_fwlog);
-                                                 fp_fwlog = INVALID_HANDLE;
-                                         }
-                                         close(newsockfd);
-                                         break;
-                                 }
-
-                                 sent_bytes = 0;
-                                 while( n > 0 )
-                                 {
-                                         printf("recved = %d\r\n",n);
-                                         sent_bytes = send(newsockfd,(char *)(buffer + sent_bytes),n,0);
-                                         if (sent_bytes < 0)
-                                         {
-                                                 error("Send failed!");
-                                                 break;
-                                         }
-                                         n -= sent_bytes;
-                                         printf("sent_bytes=%d, n=%d\n", sent_bytes,n);
-                                 }
-
-                                 n = recv(newsockfd, &ka_buff, 1, 0);
-
-                                 if (n < 0) {
-                                         error("keep alive timeout\r\n");
-                                         if(fp_fwlog != INVALID_HANDLE) {
-                                                 close(fp_fwlog);
-                                                 fp_fwlog = INVALID_HANDLE;
-                                         }
-                                         close(newsockfd);
-                                         break;
-                                 }
-                         } while(1);
-                 }
      }
 
      return 0;