tools/osyncbinary.c

   1 #include <opensync/opensync.h>
   2 #include <opensync/opensync_internals.h>
   3 #include <opensync/opensync_support_internals.h>
   4 #include <errno.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <sys/types.h>
   9 //#include <sys/wait.h>
  10 #include <glib.h>
  11
  12
  13 static void usage (char *name, int ecode)
  14 {
  15         fprintf (stderr, "Usage: %s\n", name);
  16         fprintf (stderr, "%s <Input> <Output>\n", name);
  17         fprintf (stderr, "[--hex]\tConvert from a plain hex format\n");
  18         exit (ecode);
  19 }
  20
  21 osync_bool convert_hex(const char *input, unsigned int inpsize, char **output, unsigned int *outsize)
  22 {
  23         int i = 0;
  24         GString *string = g_string_new("");
  25         unsigned int character = 0;
  26         for (i = 0; i < inpsize - 1; i = i + 2) {
  27                 char tmp[3];
  28                 printf("Current char is %c%c\n", input[i], input[i + 1]);
  29
  30                 tmp[0] = input[i];
  31                 tmp[1] = input[i + 1];
  32                 tmp[2] = 0;
  33
  34                 sscanf(tmp, " %x", &character);
  35                 g_string_append_c(string, character);
  36         }
  37
  38         *outsize = string->len;
  39         *output = g_string_free(string, FALSE);
  40         return TRUE;
  41 }
  42
  43 osync_bool convert_bin(const char *input, unsigned int inpsize, char **output, unsigned int *outsize)
  44 {
  45         int i = 0;
  46         GString *string = g_string_new("");
  47
  48         for (i = 0; i < inpsize; i++) {
  49                 unsigned int character = 0;
  50                 printf("\nCurrent char is %i (%c)\n", input[i], input[i]);
  51                 if (input[i] == '\r' || input[i] == '\n') {
  52                         printf("Invalid input\n");
  53                         return FALSE;
  54                 }
  55
  56                 //char string1[2] = "";
  57                 //char string2[3] = "";
  58                 //int ret = ;
  59                 printf("returned is %i\n", sscanf(input + i, " %x %*s", &character));
  60                 printf("returned is %i\n", sscanf(input + i, " %x %*s", &character));
  61                 if (g_pattern_match_simple(" ?? *", input + i) && sscanf(input + i, " %x %*s", &character) == 1) {
  62                         printf("returned is %i\n", sscanf(input + i, " %x %*s", &character));
  63
  64                         //if () { //0-9][0-9]
  65
  66                         printf("escaped chars are %.4s %i\n", input + i, sscanf(input + i, " %x %*s", &character));
  67                         printf("returned is %i\n", sscanf(input + i, " %x %*s", &character));
  68                         if (sscanf(input + i, " %x %*s", &character) != 1)
  69                                 return FALSE;
  70                         printf("Found a escaped char %i\n", character);
  71                         g_string_append_c(string, character);
  72                         i+=3;
  73                 } else {
  74                         if (input[i] != 0) {
  75                                 printf("Appending normal char %i\n", input[i]);
  76                                 g_string_append_c(string, input[i]);
  77                         }
  78                 }
  79         }
  80
  81         *outsize = string->len;
  82         *output = g_string_free(string, FALSE);
  83         return TRUE;
  84 }
  85
  86 int main (int argc, char *argv[])
  87 {
  88         OSyncError *error = NULL;
  89
  90         osync_bool hex = FALSE;
  91         int i = 1;
  92         char *input = NULL;
  93         char *output = NULL;
  94         char *buffer = NULL;
  95         unsigned int size = 0;
  96         char **array = NULL;
  97         char *outbuffer = NULL;
  98         unsigned int outsize = 0;
  99
 100         if (argc < 3)
 101                 usage (argv[0], 1);
 102
 103         for (i = 1; i < argc; i++) {
 104                 char *arg = argv[i];
 105                 if (!strcmp (arg, "--hex")) {
 106                         hex = TRUE;
 107                 } else if (!strcmp (arg, "--help")) {
 108                         usage (argv[0], 0);
 109                 } else {
 110                         break;
 111                 }
 112         }
 113
 114         input = argv[i];
 115         output = argv[i + 1];
 116
 117         printf("input %s output %s\n", input, output);
 118
 119         if (!osync_file_read(input, &buffer, &size, &error)) {
 120                 fprintf(stderr, "%s\n", osync_error_print(&error));
 121                 osync_error_unref(&error);
 122                 return 1;
 123         }
 124
 125         array = g_strsplit(buffer, "\n", 0);
 126         g_free(buffer);
 127         buffer = g_strjoinv(NULL, array);
 128         size = strlen(buffer) + 1;
 129         g_strfreev(array);
 130
 131         if (hex) {
 132                 if (!convert_hex(buffer, size, &outbuffer, &outsize)) {
 133                         fprintf(stderr, "Unable to convert");
 134                         return 1;
 135                 }
 136         } else {
 137                 if (!convert_bin(buffer, size, &outbuffer, &outsize)) {
 138                         fprintf(stderr, "Unable to convert");
 139                         return 1;
 140                 }
 141         }
 142
 143         if (!osync_file_write(output, outbuffer, outsize, 0644, &error)) {
 144                 fprintf(stderr, "Unable to write file %s: %s", output, osync_error_print(&error));
 145                 osync_error_unref(&error);
 146                 return 1;
 147         }
 148
 149         return 0;
 150 }