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(void);
  29 struct config config;
  30
  31
  32 struct netnode *load_node(char *nodename)
  33 {
  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(struct netnode *nnptr)
  72 {
  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(void) {
  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(void) {
 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(char *NewNodeName)
 141 {
 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(char *NodeName)
 169 {
 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(char *NodeName)
 197 {
 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(char *NodeName)
 225 {
 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(char *nodename, char *spoolcmd)
 248 {
 249         struct netnode *nnptr;
 250
 251         nnptr = load_node(nodename);
 252         if (nnptr == NULL) {
 253                 fprintf(stderr, "No such node '%s'.\n", nodename);
 254                 exit(4);
 255                 }
 256
 257         strncpy(nnptr->nn_spoolcmd, spoolcmd, 255);
 258         save_node(nnptr);
 259         }
 260
 261
 262 /*
 263  */
 264 void add_share(char *nodename, char *roomname)
 265 {
 266         struct netnode *nnptr;
 267         struct roomshare *rsptr;
 268         long highest = 0L;
 269         int foundit = 0;
 270
 271         nnptr = load_node(nodename);
 272         if (nnptr == NULL) {
 273                 fprintf(stderr, "No such node '%s'.\n", nodename);
 274                 exit(4);
 275                 }
 276
 277         for (rsptr = nnptr->nn_first; rsptr != NULL; rsptr = rsptr->next) {
 278                 if (!strcasecmp(rsptr->rs_name, roomname)) {
 279                         foundit = 1;
 280                         }
 281                 if (rsptr->rs_lastsent > highest) {
 282                         highest = rsptr->rs_lastsent;
 283                         }
 284                 }
 285
 286         if (foundit == 0) {
 287                 rsptr = (struct roomshare *) malloc(sizeof(struct roomshare));
 288                 rsptr->next = nnptr->nn_first;
 289                 strcpy(rsptr->rs_name, roomname);
 290                 rsptr->rs_lastsent = highest;
 291                 nnptr->nn_first = rsptr;
 292                 }
 293
 294         save_node(nnptr);
 295         }
 296
 297
 298 /*
 299  */
 300 void remove_share(char *nodename, char *roomname)
 301 {
 302         struct netnode *nnptr;
 303         struct roomshare *rsptr, *rshold;
 304         int foundit = 0;
 305
 306         nnptr = load_node(nodename);
 307         if (nnptr == NULL) {
 308                 fprintf(stderr, "No such node '%s'.\n", nodename);
 309                 exit(4);
 310                 }
 311
 312         if (nnptr->nn_first != NULL)
 313            if (!strcasecmp(nnptr->nn_first->rs_name, roomname)) {
 314                 rshold = nnptr->nn_first;
 315                 nnptr->nn_first = nnptr->nn_first->next;
 316                 free(rshold);
 317                 foundit = 1;
 318                 }
 319
 320         if (nnptr->nn_first != NULL)
 321            for (rsptr = nnptr->nn_first; rsptr->next != NULL; rsptr = rsptr->next) {
 322                 if (!strcasecmp(rsptr->next->rs_name, roomname)) {
 323                         rshold = rsptr->next;
 324                         rsptr->next = rsptr->next->next;
 325                         free(rshold);
 326                         foundit = 1;
 327                         rsptr = nnptr->nn_first;
 328                         }
 329                 }
 330
 331         save_node(nnptr);
 332
 333         if (foundit == 0) {
 334                 fprintf(stderr, "Not sharing '%s' with %s\n",
 335                         roomname, nodename);
 336                 exit(5);
 337                 }
 338         }
 339
 340
 341 int main(int argc, char **argv)
 342 {
 343
 344         if (argc < 2) {
 345                 display_usage();
 346                 exit(1);
 347                 }
 348
 349         get_config();
 350
 351         if (!strcmp(argv[1], "help")) {
 352                 display_usage();
 353                 exit(0);
 354                 }
 355
 356         if (!strcmp(argv[1], "nodelist")) {
 357                 display_nodelist();
 358                 exit(0);
 359                 }
 360
 361         if (!strcmp(argv[1], "addnode")) {
 362                 if (argc < 3) {
 363                         display_usage();
 364                         exit(1);
 365                         }
 366                 add_node(argv[2]);
 367                 exit(0);
 368                 }
 369
 370         if (!strcmp(argv[1], "deletenode")) {
 371                 if (argc < 3) {
 372                         display_usage();
 373                         exit(1);
 374                         }
 375                 delete_node(argv[2]);
 376                 exit(0);
 377                 }
 378
 379         if (!strcmp(argv[1], "roomlist")) {
 380                 if (argc < 3) {
 381                         display_usage();
 382                         exit(1);
 383                         }
 384                 do_roomlist(argv[2]);
 385                 exit(0);
 386                 }
 387
 388         if (!strcmp(argv[1], "getcommand")) {
 389                 if (argc < 3) {
 390                         display_usage();
 391                         exit(1);
 392                         }
 393                 show_spool_cmd(argv[2]);
 394                 exit(0);
 395                 }
 396
 397         if (!strcmp(argv[1], "setcommand")) {
 398                 if (argc < 4) {
 399                         display_usage();
 400                         exit(1);
 401                         }
 402                 set_spool_cmd(argv[2], argv[3]);
 403                 exit(0);
 404                 }
 405
 406         if (!strcmp(argv[1], "share")) {
 407                 if (argc < 4) {
 408                         display_usage();
 409                         exit(1);
 410                         }
 411                 add_share(argv[2], argv[3]);
 412                 exit(0);
 413                 }
 414
 415         if (!strcmp(argv[1], "unshare")) {
 416                 if (argc < 4) {
 417                         display_usage();
 418                         exit(1);
 419                         }
 420                 remove_share(argv[2], argv[3]);
 421                 exit(0);
 422                 }
 423
 424         display_usage();
 425         exit(1);
 426         }