src/libsmooth/main.c

   1 /* SmoothWall libsmooth.
   2  *
   3  * This program is distributed under the terms of the GNU General Public
   4  * Licence.  See the file COPYING for details.
   5  *
   6  * (c) Lawrence Manning, 2001
   7  * Contains library functions.
   8  */
   9
  10 #include "libsmooth.h"
  11
  12 #include <libintl.h>
  13 #define _(x) dgettext("libsmooth", x)
  14
  15 /* stripnl().  Replaces \n with \0 */
  16 void stripnl(char *s) {
  17         char *t = strchr(s, '\n');
  18         if (t)
  19                 *t = '\0';
  20 }
  21
  22 /* Little wrapper. */
  23 int mysystem(const char* output, const char *command) {
  24         char mycommand[STRING_SIZE];
  25
  26         if (output == NULL)
  27                 output = "/dev/null";
  28
  29         snprintf(mycommand, sizeof(mycommand), "%s >>%s 2>&1", command, output);
  30
  31         FILE* f = fopen(output, "w+");
  32         fprintf(f, "Running command: %s\n", command);
  33         fclose(f);
  34
  35         return system(mycommand);
  36 }
  37
  38 void errorbox(char *message) {
  39         newtWinMessage(_("Error"), _("OK"), message);
  40 }
  41
  42 void statuswindow(int width, int height, const char *title, const char *text, ...) {
  43         newtComponent t, f;
  44         char *buf = NULL;
  45         int size = 0;
  46         int i = 0;
  47         va_list args;
  48
  49         va_start(args, text);
  50
  51         do {
  52                 size += 1000;
  53                 if (buf) free(buf);
  54                 buf = malloc(size);
  55                 i = vsnprintf(buf, size, text, args);
  56         } while (i == size);
  57
  58         va_end(args);
  59
  60         newtCenteredWindow(width, height, title);
  61
  62         t = newtTextbox(1, 1, width - 2, height - 2, NEWT_TEXTBOX_WRAP);
  63         newtTextboxSetText(t, buf);
  64         f = newtForm(NULL, NULL, 0);
  65
  66         free(buf);
  67
  68         newtFormAddComponent(f, t);
  69
  70         newtDrawForm(f);
  71         newtRefresh();
  72         newtFormDestroy(f);
  73 }
  74
  75 int runcommandwithstatus(const char *command, const char* title, const char *message, const char* output) {
  76         statuswindow(60, 4, title, message);
  77
  78         int rc = mysystem(output, command);
  79         newtPopWindow();
  80
  81         return rc;
  82 }
  83
  84 int runhiddencommandwithstatus(const char *command, const char* title, const char *message, const char* output) {
  85         statuswindow(60, 4, title, message);
  86
  87         int rc = mysystem(output, command);
  88         newtPopWindow();
  89
  90         return rc;
  91 }
  92
  93 int splashWindow(const char* title, const char* message, unsigned int timeout) {
  94         statuswindow(60, 4, title, message);
  95
  96         // Wait so the user can read this message
  97         sleep(timeout);
  98         newtPopWindow();
  99
 100         return 0;
 101 }
 102
 103 /* This one borrowed from redhat installer. */
 104 int runcommandwithprogress(int width, int height, const char *title, const char *command,
 105         int lines, char *text, ...) {
 106         newtComponent t, f, s;
 107         char *buf = NULL;
 108         int size = 0;
 109         int i = 0;
 110         va_list args;
 111         int rc = 0;
 112         FILE *p;
 113         char buffer[STRING_SIZE];
 114         int progress = 0;
 115         char mycommand[STRING_SIZE];
 116
 117         va_start(args, text);
 118
 119         do {
 120                 size += 1000;
 121                 if (buf) free(buf);
 122                 buf = malloc(size);
 123                 i = vsnprintf(buf, size, text, args);
 124         } while (i == size);
 125
 126         va_end(args);
 127
 128         newtCenteredWindow(width, height, title);
 129
 130         t = newtTextbox(1, 1, width - 2, height - 2, NEWT_TEXTBOX_WRAP);
 131         newtTextboxSetText(t, buf);
 132         f = newtForm(NULL, NULL, 0);
 133
 134         free(buf);
 135
 136         newtFormAddComponent(f, t);
 137
 138         s = newtScale(1, 3, width - 2, lines);
 139         newtScaleSet(s, progress);
 140
 141         newtFormAddComponent(f, s);
 142
 143         newtDrawForm(f);
 144         newtRefresh();
 145
 146         if (!(p = popen(command, "r")))
 147         {
 148                 rc = 1;
 149                 goto EXIT;
 150         }
 151         setvbuf(p, NULL, _IOLBF, 255);
 152
 153         while (fgets(buffer, STRING_SIZE, p)) {
 154                 newtScaleSet(s, ++progress);
 155                 newtRefresh();
 156         }
 157
 158         rc = pclose(p);
 159
 160 EXIT:
 161         newtFormDestroy(f);
 162         newtPopWindow();
 163
 164         return rc;
 165 }
 166
 167 int checkformodule(const char *module) {
 168         FILE *file;
 169         char buffer[STRING_SIZE];
 170         int result = 0;
 171
 172         if (!(file = fopen("/proc/modules", "r")))
 173         {
 174                 fprintf(stderr, "Unable to open /proc/modules in checkformodule()\n");
 175                 return 0;
 176         }
 177
 178         while (fgets(buffer, STRING_SIZE, file))
 179         {
 180                 if (strncmp(buffer, module, strlen(module)) == 0)
 181                 {
 182                         if (buffer[strlen(module)] == ' ')
 183                         {
 184                                 result = 1;
 185                                 goto EXIT;
 186                         }
 187                 }
 188         }
 189
 190 EXIT:
 191         fclose(file);
 192
 193         return result;
 194 }
 195
 196 int _replace_string(char string[], char *from, char *to)
 197 {
 198         int fromlen = strlen(from);
 199         int tolen = strlen(to);
 200         char *start, *p1, *p2;
 201         for(start = string; *start != '\0'; start++)
 202         {
 203                 p1 = from;
 204                 p2 = start;
 205                 while(*p1 != '\0')
 206                 {
 207                         if(*p1 != *p2)
 208                                 break;
 209                         p1++;
 210                         p2++;
 211                 }
 212                 if(*p1 == '\0')
 213                 {
 214                         if(fromlen != tolen)
 215                         {
 216                                 memmove(start + tolen, start + fromlen,
 217                                         strlen(start + fromlen) + 1);
 218                         }
 219                         for(p1 = to; *p1 != '\0'; p1++)
 220                                 *start++ = *p1;
 221                         return 1;
 222                 }
 223         }
 224         return 0;
 225 }
 226
 227 int replace(char filename1[], char *from, char *to) {
 228         FILE *file1, *file2;
 229         char filename2[1000];
 230         char temp[1000];
 231         int ret = 0;
 232
 233         /* Open the source and destination files */
 234         strcpy (filename2, filename1);
 235         strcat (filename2, ".new");
 236         if (!(file1 = fopen (filename1, "r"))) return 1;
 237         if (!(file2 = fopen (filename2, "w"))) {
 238                 fclose(file1);
 239                 return -1;
 240         }
 241
 242         /* Start reading in lines */
 243         while (fgets (temp, 1000, file1) != NULL) {
 244                 if (strlen(to) > 0) {
 245                         /* Replace string */
 246                         ret = _replace_string (temp, from, to);
 247
 248                         /* Write string to new file */
 249                         fputs(temp, file2);
 250                 } else {
 251                         /* Remove string when to is NULL */
 252                         if (!strstr(temp, from))
 253                                 fputs(temp, file2);
 254                 }
 255         }
 256
 257         /* Close source and destination */
 258         fclose (file1);
 259         fclose (file2);
 260
 261         /* Move the file */
 262         rename (filename2, filename1);
 263
 264         return (ret);
 265 }
 266
 267 // returns a pointer to the actual running version number of IPFire.
 268 // Successive updates increase effective version but not VERSION !
 269 char g_title[STRING_SIZE] = "";
 270 char* get_version(void) {
 271         FILE *f_title;
 272         if ((f_title = fopen ("/etc/issue", "r"))) {
 273                 fgets (g_title, STRING_SIZE, f_title);
 274                 fclose (f_title);
 275                 if (g_title[strlen(g_title) - 1] == '\n') g_title[strlen(g_title) - 1] = '\0';
 276         }
 277         return g_title;
 278 }