incremental/afs.c

   1 /* $Header$
   2  *
   3  * Do AFS incremental updates
   4  *
   5  * Copyright (C) 1989,1992 by the Massachusetts Institute of Technology
   6  * for copying and distribution information, please see the file
   7  * <mit-copyright.h>.
   8  */
   9
  10 #include <stdio.h>
  11 #include <sys/types.h>
  12 #include <sys/file.h>
  13 #include <strings.h>
  14
  15 #include <krb.h>
  16 #include <moira.h>
  17 #include <moira_site.h>
  18
  19 #include <afs/param.h>
  20 #include <afs/cellconfig.h>
  21 #include <afs/venus.h>
  22 #include <afs/ptclient.h>
  23 #include <afs/pterror.h>
  24
  25 #define STOP_FILE "/moira/afs/noafs"
  26 #define file_exists(file) (access((file), F_OK) == 0)
  27
  28 #if defined(vax) && !defined(__STDC__)
  29 #define volatile
  30 #endif
  31
  32 char *whoami;
  33
  34 /* Main stub routines */
  35 int do_user();
  36 int do_list();
  37 int do_member();
  38 int do_filesys();
  39 int do_quota();
  40
  41 /* Support stub routines */
  42 int run_cmd();
  43 int add_user_lists();
  44 int get_members();
  45 int edit_group();
  46 int pr_try();
  47 int check_afs();
  48
  49 /* libprot.a routines */
  50 extern long pr_Initialize();
  51 extern long pr_CreateUser();
  52 extern long pr_CreateGroup();
  53 extern long pr_DeleteByID();
  54 extern long pr_ChangeEntry();
  55 extern long pr_SetFieldsEntry();
  56 extern long pr_AddToGroup();
  57 extern long pr_RemoveUserFromGroup();
  58
  59 static char tbl_buf[1024];
  60
  61 main(argc, argv)
  62 char **argv;
  63 int argc;
  64 {
  65     int beforec, afterc, i;
  66     char *table, **before, **after;
  67
  68     for (i = getdtablesize() - 1; i > 2; i--)
  69       close(i);
  70
  71     table = argv[1];
  72     beforec = atoi(argv[2]);
  73     before = &argv[4];
  74     afterc = atoi(argv[3]);
  75     after = &argv[4 + beforec];
  76     whoami = argv[0];
  77
  78     setlinebuf(stdout);
  79
  80     strcpy(tbl_buf, table);
  81     strcat(tbl_buf, " (");
  82     for (i = 0; i < beforec; i++) {
  83         if (i > 0)
  84           strcat(tbl_buf, ",");
  85         strcat(tbl_buf, before[i]);
  86     }
  87     strcat(tbl_buf, ")->(");
  88     for (i = 0; i < afterc; i++) {
  89         if (i > 0)
  90           strcat(tbl_buf, ",");
  91         strcat(tbl_buf, after[i]);
  92     }
  93     strcat(tbl_buf, ")");
  94 #ifdef DEBUG
  95     printf("%s\n", tbl_buf);
  96 #endif
  97
  98     initialize_sms_error_table();
  99     initialize_krb_error_table();
 100
 101     if (!strcmp(table, "users")) {
 102         do_user(before, beforec, after, afterc);
 103     } else if (!strcmp(table, "list")) {
 104         do_list(before, beforec, after, afterc);
 105     } else if (!strcmp(table, "members")) {
 106         do_member(before, beforec, after, afterc);
 107     } else if (!strcmp(table, "filesys")) {
 108         do_filesys(before, beforec, after, afterc);
 109     } else if (!strcmp(table, "quota")) {
 110         do_quota(before, beforec, after, afterc);
 111     }
 112     exit(0);
 113 }
 114
 115
 116 do_user(before, beforec, after, afterc)
 117 char **before;
 118 int beforec;
 119 char **after;
 120 int afterc;
 121 {
 122     int astate, bstate, auid, buid, code;
 123     char hostname[64];
 124     char *av[2];
 125
 126     auid = buid = astate = bstate = 0;
 127     if (afterc > U_STATE) astate = atoi(after[U_STATE]);
 128     if (beforec > U_STATE) bstate = atoi(before[U_STATE]);
 129     if (afterc > U_UID) auid = atoi(after[U_UID]);
 130     if (beforec > U_UID) buid = atoi(before[U_UID]);
 131
 132     /* We consider "half-registered" users to be active */
 133     if (astate == 2) astate = 1;
 134     if (bstate == 2) bstate = 1;
 135
 136     if (astate != 1 && bstate != 1)             /* inactive user */
 137         return;
 138
 139     if (astate == bstate && auid == buid &&
 140         !strcmp(before[U_NAME], after[U_NAME]))
 141         /* No AFS related attributes have changed */
 142         return;
 143
 144     if (astate == bstate) {
 145         /* Only a modify has to be done */
 146         code = pr_try(pr_ChangeEntry, before[U_NAME], after[U_NAME], auid, "");
 147         if (code) {
 148             critical_alert("incremental",
 149                            "Couldn't change user %s (id %d) to %s (id %d): %s",
 150                            before[U_NAME], buid, after[U_NAME], auid,
 151                            error_message(code));
 152         }
 153         return;
 154     }
 155     if (bstate == 1) {
 156         code = pr_try(pr_DeleteByID, buid);
 157         if (code && code != PRNOENT) {
 158             critical_alert("incremental",
 159                            "Couldn't delete user %s (id %d): %s",
 160                            before[U_NAME], buid, error_message(code));
 161         }
 162         return;
 163     }
 164     if (astate == 1) {
 165         code = pr_try(pr_CreateUser, after[U_NAME], &auid);
 166         if (code) {
 167             critical_alert("incremental",
 168                            "Couldn't create user %s (id %d): %s",
 169                            after[U_NAME], auid, error_message(code));
 170             return;
 171         }
 172
 173         if (bstate != 0) {
 174             /* Reactivating a user; get his group list */
 175             gethostname(hostname, sizeof(hostname));
 176             code = mr_connect(hostname);
 177             if (!code) code = mr_auth("afs.incr");
 178             if (code) {
 179                 critical_alert("incremental",
 180                                "Error contacting Moira server to retrieve grouplist of user %s: %s",
 181                                after[U_NAME], error_message(code));
 182                 return;
 183             }
 184             av[0] = "ruser";
 185             av[1] = after[U_NAME];
 186             code = mr_query("get_lists_of_member", 2, av,
 187                             add_user_lists, after[U_NAME]);
 188             if (code && code != MR_NO_MATCH)
 189                 critical_alert("incremental",
 190                                "Couldn't retrieve membership of user %s: %s",
 191                                after[U_NAME], error_message(code));
 192             mr_disconnect();
 193         }
 194         return;
 195     }
 196 }
 197
 198
 199 do_list(before, beforec, after, afterc)
 200 char **before;
 201 int beforec;
 202 char **after;
 203 int afterc;
 204 {
 205     register int agid, bgid;
 206     int ahide, bhide;
 207     long code, id;
 208     char hostname[64];
 209     char g1[PR_MAXNAMELEN], g2[PR_MAXNAMELEN];
 210     char *av[2];
 211
 212     agid = bgid = 0;
 213     if (beforec > L_GID && atoi(before[L_ACTIVE]) && atoi(before[L_GROUP])) {
 214         bgid = atoi(before[L_GID]);
 215         bhide = atoi(before[L_HIDDEN]);
 216     }
 217     if (afterc > L_GID && atoi(after[L_ACTIVE]) && atoi(after[L_GROUP])) {
 218         agid = atoi(after[L_GID]);
 219         ahide = atoi(after[L_HIDDEN]);
 220     }
 221
 222     if (agid == 0 && bgid == 0)                 /* Not active groups */
 223         return;
 224
 225     if (agid && bgid) {
 226         if (strcmp(after[L_NAME], before[L_NAME])) {
 227             /* Only a modify is required */
 228             strcpy(g1, "system:");
 229             strcpy(g2, "system:");
 230             strcat(g1, before[L_NAME]);
 231             strcat(g2, after[L_NAME]);
 232             code = pr_try(pr_ChangeEntry, g1, g2, -agid, "");
 233             if (code) {
 234                 critical_alert("incremental",
 235                                "Couldn't change group %s (id %d) to %s (id %d): %s",
 236                                before[L_NAME], -bgid, after[L_NAME], -agid,
 237                                error_message(code));
 238             }
 239         }
 240         if (ahide != bhide) {
 241             code = pr_try(pr_SetFieldsEntry, -agid, PR_SF_ALLBITS,
 242                           (ahide ? PRP_STATUS_ANY : PRP_GROUP_DEFAULT) >>PRIVATE_SHIFT,
 243                           0 /*ngroups*/, 0 /*nusers*/);
 244             if (code) {
 245                 critical_alert("incremental",
 246                                "Couldn't set flags of group %s: %s",
 247                                after[L_NAME], error_message(code));
 248             }
 249         }
 250         return;
 251     }
 252     if (bgid) {
 253         code = pr_try(pr_DeleteByID, -bgid);
 254         if (code && code != PRNOENT) {
 255             critical_alert("incremental",
 256                            "Couldn't delete group %s (id %d): %s",
 257                            before[L_NAME], -bgid, error_message(code));
 258         }
 259         return;
 260     }
 261     if (agid) {
 262         strcpy(g1, "system:");
 263         strcat(g1, after[L_NAME]);
 264         strcpy(g2, "system:administrators");
 265         id = -agid;
 266         code = pr_try(pr_CreateGroup, g1, g2, &id);
 267         if (code) {
 268             critical_alert("incremental",
 269                            "Couldn't create group %s (id %d): %s",
 270                            after[L_NAME], id, error_message(code));
 271             return;
 272         }
 273         if (ahide) {
 274             code = pr_try(pr_SetFieldsEntry, -agid, PR_SF_ALLBITS,
 275                           (ahide ? PRP_STATUS_ANY : PRP_GROUP_DEFAULT) >>PRIVATE_SHIFT,
 276                           0 /*ngroups*/, 0 /*nusers*/);
 277             if (code) {
 278                 critical_alert("incremental",
 279                                "Couldn't set flags of group %s: %s",
 280                                after[L_NAME], error_message(code));
 281             }
 282         }
 283
 284         /* We need to make sure the group is properly populated */
 285         if (beforec < L_ACTIVE || atoi(before[L_ACTIVE]) == 0) return;
 286
 287         gethostname(hostname, sizeof(hostname));
 288         code = mr_connect(hostname);
 289         if (!code) code = mr_auth("afs.incr");
 290         if (code) {
 291             critical_alert("incremental",
 292                            "Error contacting Moira server to resolve %s: %s",
 293                            after[L_NAME], error_message(code));
 294             return;
 295         }
 296         av[0] = "LIST";
 297         av[1] = after[L_NAME];
 298         get_members(2, av, after[L_NAME]);
 299
 300         mr_disconnect();
 301         return;
 302     }
 303 }
 304
 305
 306 do_member(before, beforec, after, afterc)
 307 char **before;
 308 int beforec;
 309 char **after;
 310 int afterc;
 311 {
 312     int code;
 313     char *p;
 314
 315     if ((beforec < 4 || !atoi(before[LM_END])) &&
 316         (afterc < 4 || !atoi(after[LM_END])))
 317         return;
 318
 319     if (afterc)
 320         edit_group(1, after[LM_LIST], after[LM_TYPE], after[LM_MEMBER]);
 321     if (beforec)
 322         edit_group(0, before[LM_LIST], before[LM_TYPE], before[LM_MEMBER]);
 323 }
 324
 325
 326 do_filesys(before, beforec, after, afterc)
 327 char **before;
 328 int beforec;
 329 char **after;
 330 int afterc;
 331 {
 332     char cmd[1024];
 333     int acreate, atype, btype;
 334
 335     if (afterc < FS_CREATE) {
 336         atype = acreate = 0;
 337     } else {
 338         atype = !strcmp(after[FS_TYPE], "AFS");
 339         acreate = atoi(after[FS_CREATE]);
 340     }
 341
 342     if (beforec < FS_CREATE) {
 343         if (acreate == 0 || atype == 0) return;
 344
 345         /* new locker creation */
 346         sprintf(cmd, "%s/perl -I%s %s/afs_create.pl %s %s %s %s %s %s",
 347                 BIN_DIR, BIN_DIR, BIN_DIR,
 348                 after[FS_NAME], after[FS_L_TYPE], after[FS_MACHINE],
 349                 after[FS_PACK], after[FS_OWNER], after[FS_OWNERS]);
 350         run_cmd(cmd);
 351         return;
 352     }
 353
 354     btype = !strcmp(before[FS_TYPE], "AFS");
 355     if (afterc < FS_CREATE) {
 356         if (btype)
 357             critical_alert("incremental",
 358                            "Cannot delete AFS filesystem %s: Operation not supported",
 359                            before[FS_NAME]);
 360         return;
 361     }
 362
 363     if (!acreate)
 364         return;
 365
 366     /* Are we dealing with AFS lockers (could be type ERR lockers) */
 367     if (!atype && !btype)
 368         if (strcmp(before[FS_TYPE], "ERR") || strcmp(after[FS_TYPE], "ERR"))
 369             return;
 370
 371     /* By now, we know we are simply changing AFS filesystem attributes.
 372      * Operations supported:
 373      *    Name change:  rename/remount
 374      *    Path change:  remount
 375      *    Type change:  ERR<-->AFS
 376      */
 377
 378 #if 0
 379     if (strcmp(before[FS_OWNER], after[FS_OWNER]) ||
 380         strcmp(before[FS_OWNERS], after[FS_OWNERS]))
 381     {
 382         critical_alert("incremental",
 383                        "Cannot change ownership of filesystem %s: Operation not yet supported",
 384                        after[FS_NAME]);
 385     }
 386 #endif
 387
 388     sprintf(cmd, "%s/perl -I%s %s/afs_rename.pl %s %s %s %s %s %s %s %s %s %s",
 389             BIN_DIR, BIN_DIR, BIN_DIR,
 390             before[FS_NAME], before[FS_MACHINE], before[FS_TYPE],
 391             before[FS_L_TYPE], before[FS_PACK],
 392             after[FS_NAME], after[FS_MACHINE], after[FS_TYPE],
 393             after[FS_L_TYPE], after[FS_PACK]);
 394     run_cmd(cmd);
 395 }
 396
 397
 398 do_quota(before, beforec, after, afterc)
 399 char **before;
 400 int beforec;
 401 char **after;
 402 int afterc;
 403 {
 404     char cmd[1024];
 405
 406     if (afterc < Q_DIRECTORY || strcmp("ANY", after[Q_TYPE]) ||
 407         strncmp("/afs/", after[Q_DIRECTORY], 5))
 408         return;
 409
 410     sprintf(cmd, "%s/perl -I%s %s/afs_quota.pl %s %s",
 411             BIN_DIR, BIN_DIR, BIN_DIR,
 412             after[Q_DIRECTORY], after[Q_QUOTA]);
 413     run_cmd(cmd);
 414     return;
 415 }
 416
 417
 418 run_cmd(cmd)
 419 char *cmd;
 420 {
 421     int success=0, tries=0;
 422
 423     check_afs();
 424
 425     while (success == 0 && tries < 2) {
 426         if (tries++)
 427             sleep(90);
 428         com_err(whoami, 0, "Executing command: %s", cmd);
 429         if (system(cmd) == 0)
 430             success++;
 431     }
 432     if (!success)
 433         critical_alert("incremental", "failed command: %s", cmd);
 434 }
 435
 436
 437 add_user_lists(ac, av, user)
 438     int ac;
 439     char *av[];
 440     char *user;
 441 {
 442     if (atoi(av[5]))
 443         edit_group(1, av[0], "USER", user);
 444 }
 445
 446
 447 get_members(ac, av, group)
 448     int ac;
 449     char *av[];
 450     char *group;
 451 {
 452     int code=0;
 453
 454     if (strcmp(av[0], "LIST")) {
 455         edit_group(1, group, av[0], av[1]);
 456     } else {
 457         code = mr_query("get_end_members_of_list", 1, &av[1],
 458                         get_members, group);
 459         if (code)
 460             critical_alert("incremental",
 461                            "Couldn't retrieve full membership of %s: %s",
 462                            group, error_message(code));
 463     }
 464     return code;
 465 }
 466
 467
 468 edit_group(op, group, type, member)
 469     int op;
 470     char *group;
 471     char *type;
 472     char *member;
 473 {
 474     char *p = 0;
 475     char buf[PR_MAXNAMELEN];
 476     int code;
 477     static char local_realm[REALM_SZ+1] = "";
 478
 479     /* The following KERBEROS code allows for the use of entities
 480      * user@foreign_cell.
 481      */
 482     if (!local_realm[0])
 483         krb_get_lrealm(local_realm, 1);
 484     if (!strcmp(type, "KERBEROS")) {
 485         p = index(member, '@');
 486         if (p && !strcasecmp(p+1, local_realm))
 487             *p = 0;
 488     } else if (strcmp(type, "USER"))
 489         return;                                 /* invalid type */
 490
 491     strcpy(buf, "system:");
 492     strcat(buf, group);
 493     code=pr_try(op ? pr_AddToGroup : pr_RemoveUserFromGroup, member, buf);
 494     if (code) {
 495         if (op==0 && code == PRNOENT) return;
 496         if (op==1 && code == PRIDEXIST) return;
 497         if (strcmp(type, "KERBEROS") || code != PRNOENT) {
 498             critical_alert("incremental",
 499                            "Couldn't %s %s %s %s: %s",
 500                            op ? "add" : "remove", member,
 501                            op ? "to" : "from", buf,
 502                            error_message(code));
 503         }
 504     }
 505 }
 506
 507
 508 long pr_try(fn, a1, a2, a3, a4, a5, a6, a7, a8)
 509     long (*fn)();
 510     char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
 511 {
 512     static int initd=0;
 513     volatile register long code;
 514     register int tries = 0;
 515 #ifdef DEBUG
 516     char fname[64];
 517 #endif
 518
 519     check_afs();
 520
 521     if (!initd) {
 522         code=pr_Initialize(1, AFSCONF_CLIENTNAME, 0);
 523         if (code) {
 524             critical_alert("incremental", "Couldn't initialize libprot: %s",
 525                            error_message(code));
 526             return;
 527         }
 528         initd = 1;
 529     }
 530     sleep(1);                                   /* give ptserver room */
 531
 532     while (code = (*fn)(a1, a2, a3, a4, a5, a6, a7, a8)) {
 533 #ifdef DEBUG
 534         long t;
 535         t = time(0);
 536         if (fn == pr_AddToGroup) strcpy(fname, "pr_AddToGroup");
 537         else if (fn == pr_RemoveUserFromGroup)
 538             strcpy(fname, "pr_RemoveUserFromGroup");
 539         else if (fn == pr_CreateUser) strcpy(fname, "pr_CreateUser");
 540         else if (fn == pr_CreateGroup) strcpy(fname, "pr_CreateGroup");
 541         else if (fn == pr_DeleteByID) strcpy(fname, "pr_DeleteByID");
 542         else if (fn == pr_ChangeEntry) strcpy(fname, "pr_ChangeEntry");
 543         else if (fn == pr_SetFieldsEntry) strcpy(fname, "pr_SetFieldsEntry");
 544         else if (fn == pr_AddToGroup) strcpy(fname, "pr_AddToGroup");
 545         else
 546             sprintf(fname, "pr_??? (0x%08x)", (long)fn);
 547
 548         com_err(whoami, code, "- %s failed (try %d @%u)", fname, tries+1, t);
 549 #endif
 550         if (++tries > 2) break;         /* 3 tries */
 551
 552         if (code == UNOQUORUM) sleep(90);
 553         else sleep(15);
 554
 555         /* Re-initialize the prdb connection */
 556         code=pr_Initialize(0, AFSCONF_CLIENTNAME, 0);
 557         if (!code) code=pr_Initialize(1, AFSCONF_CLIENTNAME, 0);
 558         if (code) {
 559             critical_alert("incremental", "Couldn't re-initialize libprot: %s",
 560                            error_message(code));
 561             initd = 0;                          /* we lost */
 562             break;
 563         }
 564     }
 565     return code;
 566 }
 567
 568
 569 check_afs()
 570 {
 571     int i;
 572
 573     for (i=0; file_exists(STOP_FILE); i++) {
 574         if (i > 30) {
 575             critical_alert("incremental",
 576                            "AFS incremental failed (%s exists): %s",
 577                            STOP_FILE, tbl_buf);
 578             exit(1);
 579         }
 580         sleep(60);
 581     }
 582 }