afssync/sync.qc

   1 /* $Header$
   2  *
   3  * This generates the zone files necessary to load a hesiod server.
   4  * The following zones are generated: passwd, uid, pobox, group,
   5  * grplist, gid, filsys, cluster, pcap, sloc, service.
   6  *
   7  *  (c) Copyright 1988 by the Massachusetts Institute of Technology.
   8  *  For copying and distribution information, please see the file
   9  *  <mit-copyright.h>.
  10  */
  11
  12 #include <mit-copyright.h>
  13 #include <stdio.h>
  14 #include <sys/file.h>
  15 #include <rx/xdr.h>
  16 #include "print.h"
  17 #include "prserver.h"
  18 #include "prerror.h"
  19 #include <sms.h>
  20 #include <sms_app.h>
  21 #include <ctype.h>
  22
  23 #define USERSMS 14487
  24
  25 #define min(x,y)        ((x) < (y) ? (x) : (y))
  26 struct hash *users = NULL;
  27 char *whoami = "sync";
  28
  29 char *malloc(), *strsave();
  30 int dbase_fd;
  31
  32
  33 main(argc, argv)
  34 int argc;
  35 char **argv;
  36 {
  37     int status;
  38     int ingerr();
  39
  40     if (argc != 2) {
  41         fprintf(stderr, "usage: %s outfile\n", argv[0]);
  42         exit(SMS_ARGS);
  43     }
  44
  45     dbase_fd = open(argv[1], O_RDWR|O_CREAT, 0660);
  46     if (dbase_fd < 0) {
  47         perror("opening file %s", argv[1]);
  48         exit(1);
  49     }
  50     IIseterr(ingerr);
  51     initialize_sms_error_table ();
  52
  53 ##  ingres sms
  54 ##  set lockmode session where level = table
  55 ##  begin transaction
  56
  57     do_passwd();
  58     status = PR_AddToGroup(NULL, USERSMS, SYSADMINID);
  59     if (status) {
  60         prserror(status, "adding SMS to system:administrators", 0, 0);
  61     }
  62     do_groups();
  63
  64 ##  end transaction
  65 ##  exit
  66
  67     exit(SMS_SUCCESS);
  68 }
  69
  70
  71 /*
  72  * ingerr: (supposedly) called when Ingres indicates an error.
  73  * I have not yet been able to get this to work to intercept a
  74  * database open error.
  75  */
  76 #define INGRES_DEADLOCK 4700
  77
  78 static int ingerr(num)
  79     int *num;
  80 {
  81     char buf[256];
  82     int ingres_errno;
  83
  84     switch (*num) {
  85     case INGRES_DEADLOCK:
  86         ingres_errno = SMS_DEADLOCK;
  87         break;
  88     default:
  89         ingres_errno = SMS_INGRES_ERR;
  90     }
  91     com_err(whoami, SMS_INGRES_ERR, " code %d\n", *num);
  92     exit(ingres_errno);
  93 }
  94
  95
  96 prserror(status, msg, arg1, arg2)
  97 int status;
  98 char *msg;
  99 unsigned long arg1, arg2;
 100 {
 101     char buf[512];
 102
 103     sprintf(buf, msg, arg1, arg2);
 104     switch (status) {
 105     case PREXIST:
 106         msg = "name already exists";
 107         break;
 108     case PRIDEXIST:
 109         msg = "ID already exists";
 110         break;
 111     case PRNOIDS:
 112         msg = "no IDs available";
 113         break;
 114     case PRDBFAIL:
 115         msg = "database failed";
 116         break;
 117     case PRNOENT:
 118         msg = "no space left in database";
 119         break;
 120     case PRPERM:
 121         msg = "permission denied";
 122         break;
 123     case PRNOTGROUP:
 124         msg = "not a group";
 125         break;
 126     case PRNOTUSER:
 127         msg = "not a user";
 128         break;
 129     case PRBADNAM:
 130         msg = "bad name";
 131         break;
 132     case 0:
 133         msg = "no error";
 134         break;
 135     default:
 136         msg = "unknown code";
 137         break;
 138     }
 139     fprintf(stderr, "%s (%d): %s\n", msg, status, buf);
 140 }
 141
 142
 143
 144 do_passwd()
 145 ##{
 146 ##  char login[9];
 147 ##  int uid, id, status;
 148
 149     fprintf(stderr, "Doing users\n");
 150     users = create_hash(10000);
 151 ##  range of u is users
 152 ##  retrieve (login = u.#login, uid = u.#uid, id = u.users_id)
 153 ##      where u.#status = 1 {
 154             strtrim(login);
 155             hash_store(users, id, uid);
 156             status = PR_INewEntry(NULL, login, uid, 0);
 157             if (status) {
 158                 prserror(status, "adding user %s uid %d", login, uid);
 159             }
 160 ##  }
 161 ##}
 162
 163
 164
 165 do_groups()
 166 ##{
 167     struct hash *groups;
 168     long u, g, status;
 169 ##  char name[33], namebuf[128];
 170 ##  int gid, id, lid;
 171
 172     fprintf(stderr, "Doing groups\n");
 173
 174     /* make space for group list */
 175     groups = create_hash(15000);
 176
 177     /* retrieve simple groups */
 178 ##  range of l is list
 179 ##  range of m is imembers
 180     /* get lock records */
 181 ##  retrieve (name = l.modtime) where l.list_id = 0
 182 ##  retrieve (name = users.modtime) where users.users_id = 0
 183
 184 ##  retrieve (name = l.#name, gid = l.#gid, lid = l.list_id)
 185 ##      where l.group != 0 and l.active != 0 {
 186             strtrim(name);
 187             sprintf(namebuf, "system:%s", name);
 188             hash_store(groups, lid, -gid);
 189             status = PR_INewEntry(NULL, namebuf, -gid, SYSADMINID);
 190             if (status)
 191               prserror(status, "adding list %s gid %d", namebuf, -gid);
 192 ##  }
 193
 194
 195     fprintf(stderr, "Doing members\n");
 196
 197 ##  retrieve (lid = m.list_id, id = m.member_id)
 198 ##      where m.member_type = "USER" {
 199       if ((u = (long) hash_lookup(users, id)) &&
 200           (g = (long) hash_lookup(groups, lid))) {
 201           status = PR_AddToGroup(NULL, u, g);
 202           if (status) {
 203               prserror(status, "adding %d to group %d", u, -g);
 204           }
 205       }
 206 ##  }
 207
 208 ##}
 209