citadel/netsetup.c

   1 /*
   2  * netsetup.c
   3  *
   4  * Copyright (c) 1998  Art Cancro
   5  *
   6  */
   7
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <errno.h>
  13 #include "citadel.h"
  14
  15 struct roomshare {
  16         struct roomshare *next;
  17         char rs_name[30];
  18         long rs_lastsent;
  19         };
  20
  21 struct netnode {
  22         char nn_nodename[32];
  23         char nn_spoolcmd[256];
  24         struct roomshare *nn_first;
  25         };
  26
  27
  28 void get_config();
  29 struct config config;
  30
  31
  32 struct netnode *load_node(nodename)
  33 char *nodename; {
  34         FILE *fp;
  35         char buf[256];
  36         char filename[256];
  37         struct netnode *newnn;
  38         struct roomshare *newrs;
  39
  40         sprintf(filename, "./network/systems/%s", nodename);
  41         fp = fopen(filename, "r");
  42         if (fp == NULL) {
  43                 return NULL;
  44                 }
  45
  46         newnn = (struct netnode *) malloc(sizeof(struct netnode));
  47         strcpy(newnn->nn_nodename, nodename);
  48         newnn->nn_first = NULL;
  49
  50         fgets(buf, 255, fp);
  51         buf[strlen(buf)-1] = 0;
  52         strcpy(newnn->nn_spoolcmd, buf);
  53
  54         while (fgets(buf, 255, fp) != NULL) {
  55                 newrs = (struct roomshare *) malloc(sizeof(struct roomshare));
  56                 newrs->next = newnn->nn_first;
  57                 newnn->nn_first = newrs;
  58                 buf[strlen(buf)-1] = 0;
  59                 strcpy(newrs->rs_name, buf);
  60                 fgets(buf, 255, fp);
  61                 buf[strlen(buf)-1] = 0;
  62                 newrs->rs_lastsent = atol(buf);
  63                 }
  64
  65         fclose(fp);
  66         return(newnn);
  67         }
  68
  69
  70
  71 void save_node(nnptr)
  72 struct netnode *nnptr; {
  73
  74         FILE *fp;
  75         char filename[256];
  76         struct roomshare *rsptr = NULL;
  77
  78         sprintf(filename, "./network/systems/%s", nnptr->nn_nodename);
  79         fp = fopen(filename, "w");
  80         if (fp == NULL) {
  81                 fprintf(stderr, "%s\n", strerror(errno));
  82                 return;
  83                 }
  84         fprintf(fp, "%s\n", nnptr->nn_spoolcmd);
  85         while (nnptr->nn_first != NULL) {
  86                 fprintf(fp, "%s\n%ld\n", nnptr->nn_first->rs_name,
  87                                         nnptr->nn_first->rs_lastsent);
  88                 rsptr = nnptr->nn_first->next;
  89                 free(nnptr->nn_first);
  90                 nnptr->nn_first = rsptr;
  91                 }
  92         fclose(fp);
  93         free(rsptr);
  94         }
  95
  96
  97
  98 void display_usage() {
  99         fprintf(stderr, "netsetup for %s\n", CITADEL);
 100         fprintf(stderr, "usage: netsetup <command> [arguments]\n\n");
 101         fprintf(stderr, "Commands: \n");
 102         fprintf(stderr, "   nodelist                  (Lists all neighboring nodes\n");
 103         fprintf(stderr, "   addnode [name]            (Adds a new node to the list)\n");
 104         fprintf(stderr, "   deletenode [name]         (Deletes a node from the list)\n");
 105         fprintf(stderr, "   roomlist [node]           (List rooms being shared)\n");
 106         fprintf(stderr, "   getcommand [node]         (Show spool command)\n");
 107         fprintf(stderr, "   setcommand [node] [cmd]   (Set spool command)\n");
 108         fprintf(stderr, "   share [node] [room]       (Add a new shared room)\n");
 109         fprintf(stderr, "   unshare [node] [room]     (Stop sharing a room)\n");
 110         fprintf(stderr, "   help                      (Display this message)\n");
 111         }
 112
 113
 114 /*
 115  * Display all neighboring nodes
 116  * (This is inherently nonportable)
 117  */
 118 void display_nodelist() {
 119         FILE *ls;
 120         char buf[256];
 121
 122         ls = (FILE *) popen("cd ./network/systems; ls", "r");
 123         if (ls == NULL) {
 124                 fprintf(stderr, "netsetup: Cannot open nodelist: %s\n",
 125                         strerror(errno));
 126                 exit(errno);
 127                 }
 128
 129         while (fgets(buf, 255, ls) != NULL) {
 130                 printf("%s", buf);
 131                 }
 132
 133         pclose(ls);
 134         }
 135
 136
 137
 138 /*
 139  */
 140 void add_node(NewNodeName)
 141 char *NewNodeName; {
 142         FILE *fp;
 143         char sysfilename[256];
 144
 145         sprintf(sysfilename, "./network/systems/%s", NewNodeName);
 146
 147         fp = fopen(sysfilename, "r");
 148         if (fp != NULL) {
 149                 fclose(fp);
 150                 fprintf(stderr, "A node named '%s' already exists.\n",
 151                         NewNodeName);
 152                 exit(2);
 153                 }
 154
 155         fp = fopen(sysfilename, "w");
 156         if (fp == NULL) {
 157                 fprintf(stderr, "%s\n", strerror(errno));
 158                 exit(errno);
 159                 }
 160
 161         fprintf(fp, "cat %%s >>./network/spoolout/%s\n", NewNodeName);
 162         fclose(fp);
 163         }
 164
 165
 166 /*
 167  */
 168 void delete_node(NodeName)
 169 char *NodeName; {
 170         FILE *fp;
 171         char sysfilename[256];
 172         char spooloutfilename[256];
 173
 174         sprintf(sysfilename, "./network/systems/%s", NodeName);
 175         sprintf(spooloutfilename, "./network/spoolout/%s", NodeName);
 176
 177         fp = fopen(sysfilename, "r");
 178         if (fp == NULL) {
 179                 fprintf(stderr, "'%s' does not exist.\n",
 180                         NodeName);
 181                 exit(3);
 182                 }
 183         fclose(fp);
 184
 185         unlink(spooloutfilename);
 186         if (unlink(sysfilename)==0) {
 187                 return;
 188                 }
 189         fprintf(stderr, "%s\n", strerror(errno));
 190         exit(errno);
 191         }
 192
 193
 194 /*
 195  */
 196 void do_roomlist(NodeName)
 197 char *NodeName; {
 198         FILE *fp;
 199         char sysfilename[256];
 200         char buf[256];
 201
 202         sprintf(sysfilename, "./network/systems/%s", NodeName);
 203
 204         fp = fopen(sysfilename, "r");
 205         if (fp == NULL) {
 206                 fprintf(stderr, "'%s' does not exist.\n",
 207                         NodeName);
 208                 exit(3);
 209                 }
 210
 211         fgets(buf, 255, fp);    /* skip past spool cmd */
 212         while (fgets(buf, 255, fp) != NULL) {
 213                 printf("%s", buf);
 214                 fgets(buf, 255, fp);    /* skip past last-sent pointer */
 215                 }
 216
 217         fclose(fp);
 218         }
 219
 220
 221
 222 /*
 223  */
 224 void show_spool_cmd(NodeName)
 225 char *NodeName; {
 226         FILE *fp;
 227         char sysfilename[256];
 228         char buf[256];
 229
 230         sprintf(sysfilename, "./network/systems/%s", NodeName);
 231
 232         fp = fopen(sysfilename, "r");
 233         if (fp == NULL) {
 234                 fprintf(stderr, "'%s' does not exist.\n",
 235                         NodeName);
 236                 exit(3);
 237                 }
 238
 239         fgets(buf, 255, fp);
 240         printf("%s", buf);
 241         fclose(fp);
 242         }
 243
 244
 245 /*
 246  */
 247 void set_spool_cmd(nodename, spoolcmd)
 248 char *nodename;
 249 char *spoolcmd; {
 250         struct netnode *nnptr;
 251
 252         nnptr = load_node(nodename);
 253         if (nnptr == NULL) {
 254                 fprintf(stderr, "No such node '%s'.\n", nodename);
 255                 exit(4);
 256                 }
 257
 258         strncpy(nnptr->nn_spoolcmd, spoolcmd, 255);
 259         save_node(nnptr);
 260         }
 261
 262
 263 /*
 264  */
 265 void add_share(nodename, roomname)
 266 char *nodename;
 267 char *roomname; {
 268         struct netnode *nnptr;
 269         struct roomshare *rsptr;
 270         long highest = 0L;
 271         int foundit = 0;
 272
 273         nnptr = load_node(nodename);
 274         if (nnptr == NULL) {
 275                 fprintf(stderr, "No such node '%s'.\n", nodename);
 276                 exit(4);
 277                 }
 278
 279         for (rsptr = nnptr->nn_first; rsptr != NULL; rsptr = rsptr->next) {
 280                 if (!strcasecmp(rsptr->rs_name, roomname)) {
 281                         foundit = 1;
 282                         }
 283                 if (rsptr->rs_lastsent > highest) {
 284                         highest = rsptr->rs_lastsent;
 285                         }
 286                 }
 287
 288         if (foundit == 0) {
 289                 rsptr = (struct roomshare *) malloc(sizeof(struct roomshare));
 290                 rsptr->next = nnptr->nn_first;
 291                 strcpy(rsptr->rs_name, roomname);
 292                 rsptr->rs_lastsent = highest;
 293                 nnptr->nn_first = rsptr;
 294                 }
 295
 296         save_node(nnptr);
 297         }
 298
 299
 300 /*
 301  */
 302 void remove_share(nodename, roomname)
 303 char *nodename;
 304 char *roomname; {
 305         struct netnode *nnptr;
 306         struct roomshare *rsptr, *rshold;
 307         int foundit = 0;
 308
 309         nnptr = load_node(nodename);
 310         if (nnptr == NULL) {
 311                 fprintf(stderr, "No such node '%s'.\n", nodename);
 312                 exit(4);
 313                 }
 314
 315         if (nnptr->nn_first != NULL)
 316            if (!strcasecmp(nnptr->nn_first->rs_name, roomname)) {
 317                 rshold = nnptr->nn_first;
 318                 nnptr->nn_first = nnptr->nn_first->next;
 319                 free(rshold);
 320                 foundit = 1;
 321                 }
 322
 323         if (nnptr->nn_first != NULL)
 324            for (rsptr = nnptr->nn_first; rsptr->next != NULL; rsptr = rsptr->next) {
 325                 if (!strcasecmp(rsptr->next->rs_name, roomname)) {
 326                         rshold = rsptr->next;
 327                         rsptr->next = rsptr->next->next;
 328                         free(rshold);
 329                         foundit = 1;
 330                         rsptr = nnptr->nn_first;
 331                         }
 332                 }
 333
 334         save_node(nnptr);
 335
 336         if (foundit == 0) {
 337                 fprintf(stderr, "Not sharing '%s' with %s\n",
 338                         roomname, nodename);
 339                 exit(5);
 340                 }
 341         }
 342
 343
 344 int main(argc, argv)
 345 int argc;
 346 char *argv[]; {
 347
 348         if (argc < 2) {
 349                 display_usage();
 350                 exit(1);
 351                 }
 352
 353         get_config();
 354
 355         if (!strcmp(argv[1], "help")) {
 356                 display_usage();
 357                 exit(0);
 358                 }
 359
 360         if (!strcmp(argv[1], "nodelist")) {
 361                 display_nodelist();
 362                 exit(0);
 363                 }
 364
 365         if (!strcmp(argv[1], "addnode")) {
 366                 if (argc < 3) {
 367                         display_usage();
 368                         exit(1);
 369                         }
 370                 add_node(argv[2]);
 371                 exit(0);
 372                 }
 373
 374         if (!strcmp(argv[1], "deletenode")) {
 375                 if (argc < 3) {
 376                         display_usage();
 377                         exit(1);
 378                         }
 379                 delete_node(argv[2]);
 380                 exit(0);
 381                 }
 382
 383         if (!strcmp(argv[1], "roomlist")) {
 384                 if (argc < 3) {
 385                         display_usage();
 386                         exit(1);
 387                         }
 388                 do_roomlist(argv[2]);
 389                 exit(0);
 390                 }
 391
 392         if (!strcmp(argv[1], "getcommand")) {
 393                 if (argc < 3) {
 394                         display_usage();
 395                         exit(1);
 396                         }
 397                 show_spool_cmd(argv[2]);
 398                 exit(0);
 399                 }
 400
 401         if (!strcmp(argv[1], "setcommand")) {
 402                 if (argc < 4) {
 403                         display_usage();
 404                         exit(1);
 405                         }
 406                 set_spool_cmd(argv[2], argv[3]);
 407                 exit(0);
 408                 }
 409
 410         if (!strcmp(argv[1], "share")) {
 411                 if (argc < 4) {
 412                         display_usage();
 413                         exit(1);
 414                         }
 415                 add_share(argv[2], argv[3]);
 416                 exit(0);
 417                 }
 418
 419         if (!strcmp(argv[1], "unshare")) {
 420                 if (argc < 4) {
 421                         display_usage();
 422                         exit(1);
 423                         }
 424                 remove_share(argv[2], argv[3]);
 425                 exit(0);
 426                 }
 427
 428         display_usage();
 429         exit(1);
 430         }