auto reconnect, cleaup code, handle some edge cases

1 files changed, 49 insertions, 62 deletions

diff --git a/moc_library.c b/moc_library.c
index 7fd484b..ca65f20 100644
--- a/moc_library.c
+++ b/moc_library.c
@@ -77,7 +77,9 @@ enum moc_status {
   INITIALIZING,
   CONNECTED,
   FAILED_TO_CONNECT,
-  ERROR
+  ERROR,
+  RECONNECTING,
+  
 };
 
 struct moc { 
@@ -92,8 +94,14 @@ struct moc {
   int track;
   int time;
   int filled;
+  int length;
 };
 
+extern const char * moc_str_status(enum moc_status s) {
+    static const char *strings[] = { "INITIALIZING", "CONNECTED", "FAILED_TO_CONNECT", "ERROR", "RECONNECTING" };
+    return strings[s];
+}
+
 extern const char * moc_str_state(enum moc_state s) {
     static const char *strings[] = { "STOPPED", "PLAYING", "PAUSED"};
     return strings[s];
@@ -101,8 +109,6 @@ extern const char * moc_str_state(enum moc_state s) {
 }
 
 static char *get_curr_file(int sock);
-static char *get_data_str(int sock);
-static void *get_event_data (const int sock, const int type);
 int send_str (int sock, const char *str);
 char *get_str (int sock);
 int send_int (int sock, int i);
@@ -115,6 +121,8 @@ void reset_data(struct moc *data) {
   data->album = NULL;
   data->artist = NULL;
   data->time = -1;
+  data->length = -1;
+  data->state = STOPPED;
 }
 
 static char *get_curr_file (const int sock) {
@@ -122,54 +130,9 @@ static char *get_curr_file (const int sock) {
   int ev;
   while(ev != EV_DATA) {
     get_int(sock, &ev);
-    fprintf(stderr, "EVENT: 0x%02x\n", ev);
   }
     return get_str(sock);
 }
-static void wait_for_data (const int sock) {
-  int event = -1;
-  do {
-    fprintf(stderr, "waiting for data last was %d\n", event);
-    event = get_int(sock, &event);
-    if (event == EV_EXIT) {
-      fprintf(stderr, "The server exited!");
-      pthread_exit(NULL);
-    }
-    if(event == EV_STATE) {
-      char *skip;
-      skip = get_str(sock);
-      fprintf(stderr, "got str%s\n", skip);
-    }
-    if (event != EV_DATA)
-      get_event_data(sock, event);
-  } while (event != EV_DATA);
-}
-
-static void *get_event_data (const int sock, const int type)
-{
-  switch (type) {
-    case EV_PLIST_ADD:
-    case EV_QUEUE_ADD:
-      break;
-      // return recv_item_from_srv ();
-    case EV_PLIST_DEL:
-    case EV_QUEUE_DEL:
-    case EV_STATUS_MSG:
-    case EV_SRV_ERROR:
-      return get_str(sock);
-    case EV_FILE_TAGS:
-      //	return recv_tags_data_from_srv ();
-      break;
-    case EV_PLIST_MOVE:
-      break;
-  }
-
-  return NULL;
-}
-static char *get_data_str(int sock) {
-  wait_for_data (sock);
-  return get_str(sock);
-}
 
 
 int send_str (int sock, const char *str)
@@ -242,7 +205,6 @@ int get_int (int sock, int *i)
 
 static int moc_server_connect ()
 {
-  char *path = moc_socket_path;
   struct sockaddr_un sock_name;
   int sock;
 
@@ -279,6 +241,22 @@ void update_state(struct moc *data, int state) {
         fprintf(stderr, "moc: state stopped\n");
     }
 }
+
+static int moc_reconnect(struct moc *data) {
+ int srv_sock = -1;
+
+ while(srv_sock == -1) { 
+   fprintf(stderr, "moc: reconnecting\n");
+   srv_sock = moc_server_connect();
+   sleep(1);
+ }
+
+  pthread_mutex_lock(&data->lock);
+  data->status = CONNECTED;
+  pthread_mutex_unlock(&data->lock);
+  return srv_sock;
+}
+
 void *moc_loop(void *input) {
 
 
@@ -286,22 +264,19 @@ void *moc_loop(void *input) {
 
   int srv_sock = -1;
 
-  srv_sock = moc_server_connect();
-  if(srv_sock == -1) { 
-    pthread_mutex_lock(&data->lock);
-    data->status = FAILED_TO_CONNECT;
-    pthread_mutex_unlock(&data->lock);
-    pthread_exit(NULL);
-  }
+  fprintf(stderr, "moc: connecting\n");
+  srv_sock = moc_reconnect(data);
+  fprintf(stderr, "moc: connected: %d\n", srv_sock);
 
-  data->status = CONNECTED;
 
   int last_cmd = -1;
   int event = -1;
 
   send_int(srv_sock, CMD_GET_STATE);
   last_cmd = EV_STATE;
-  while(get_int(srv_sock, &event)) {
+
+  while(1) {
+    get_int(srv_sock, &event); 
     switch (event) {
       // handle our data. we MUST know what the last request was otherwise we
       // don't know how to parse it.
@@ -309,13 +284,18 @@ void *moc_loop(void *input) {
         fprintf(stderr, "moc: EV_DATA\n");
         if(last_cmd == EV_CTIME) {
           get_int(srv_sock, &data->time);
-          fprintf(stderr, "moc: update ctime\n");
+          fprintf(stderr, "moc: update ctime %d\n");
+          if(data->state == 0) {
+            send_int(srv_sock, CMD_GET_STATE);
+            last_cmd = EV_STATE;
+          }
         }
         //  on state change, we need to figure out what file we have and what
         //  tags it has.
         else if(last_cmd == EV_STATE) {
           int state;
           get_int(srv_sock, &state);
+          pthread_mutex_lock(&data->lock);
           update_state(data, state);
 
           if(state != STATE_STOP) {
@@ -334,6 +314,7 @@ void *moc_loop(void *input) {
           } else {
             reset_data(data);
           }
+          pthread_mutex_unlock(&data->lock);
         }
         else {
           fprintf(stderr, "moc: shit i have data IDK what it is\n");
@@ -356,6 +337,9 @@ void *moc_loop(void *input) {
         break;
       case EV_EXIT:
         fprintf(stderr,"moc: EV_EXIT\n");
+        data->status = RECONNECTING;
+        reset_data(data);
+        srv_sock = moc_reconnect(data);
         break;
       case EV_BITRATE:
         fprintf(stderr, "moc: EV_BITRATE\n");
@@ -367,7 +351,7 @@ void *moc_loop(void *input) {
         printf("moc: EV_CHANNELS\n");
         break;
       case EV_SRV_ERROR:
-        printf("moc: EV_SRV_ERROR\n");
+          get_str(srv_sock);
         break;
       case EV_OPTIONS:
         printf("moc: EV_OPTIONS\n");
@@ -392,6 +376,7 @@ void *moc_loop(void *input) {
       case EV_FILE_TAGS:
         printf("moc: EV_FILE_TAGS\n");
 
+        pthread_mutex_lock(&data->lock);
         if (!(data->filename = get_str(srv_sock))) {
           fprintf(stderr, "Error while receiving filename\n");
         }
@@ -412,13 +397,14 @@ void *moc_loop(void *input) {
           fprintf(stderr, "Error while receiving track\n");
         }
 
-        if (!get_int(srv_sock, &data->time)) {
-          fprintf(stderr, "Error while receiving time\n");
+        if (!get_int(srv_sock, &data->length)) {
+          fprintf(stderr, "Error while receiving length\n");
         }
 
         if (!get_int(srv_sock, &data->filled)) {
           fprintf(stderr, "Error while receiving filled\n");
         }
+        pthread_mutex_unlock(&data->lock);
 
         break;
       case EV_AVG_BITRATE:
@@ -435,6 +421,7 @@ void *moc_loop(void *input) {
         break;
     }
   }
+  fprintf(stderr, "loop died, you're fucked\n");
 }
 
 extern struct moc *moc_init() {