int main(int argc, char **argv)
{
char *prefix;
- register int i;
+ int i;
if (argc != 2)
{
punt("can't write backup file");
}
-int dump_str(register FILE *f, register char *str)
+int dump_str(FILE *f, char *str)
{
- register char *ibp;
- register int c; /* PCC doesn't put chars in registers.. */
- register int t;
+ char *ibp, c;
+ int t;
for (ibp = str; c = (unsigned char) *ibp; ibp++)
{
/*
* Trim whitespace off both ends of a string.
*/
-char *strtrim(register char *save)
+char *strtrim(char *save)
{
- register char *t, *s;
+ char *t, *s;
s = save;
while (isspace(*s))
int tt = open("/dev/tty", O_RDWR, 0);
FILE *o, *i;
- register char *cp;
+ char *cp;
if (tt < 0)
return 0;
return ret;
}
-int parse_int(register FILE *f)
+int parse_int(FILE *f)
{
- register int c;
- register int val = 0;
- register int sign = 1;
+ int c;
+ int val = 0;
+ int sign = 1;
while ((c = getc(f)) != EOF && c != SEP_CHAR && c != '\n')
{
if (c == '-')
return val * sign;
}
-void parse_str(register FILE *f, register char *buf, register int maxlen)
+void parse_str(FILE *f, char *buf, int maxlen)
{
- register int c, len = 0;
+ int c, len = 0;
while ((c = getc(f)) != EOF && c != SEP_CHAR && c != '\n' && len < maxlen)
{
if (isdigit(c))
{
/* Expect three-digit octal number.. */
- register int c1, c2;
+ int c1, c2;
c1 = getc(f);
c2 = getc(f);
if (!isdigit(c1) || !isdigit(c2))
* is not found. ';' is a comment character.
*/
-struct member *parse_member(register char *s)
+struct member *parse_member(char *s)
{
- register struct member *m;
+ struct member *m;
char *p, *lastchar;
while (*s && isspace(*s))
int CreateFSAlias(int argc, char **argv)
{
- register int stat;
+ int stat;
struct qelem *elem, *top;
char *args[MAX_ARGS_SIZE], buf[BUFSIZ], **info;
static void RealUpdateMachine(char **info, Bool junk)
{
- register int stat;
+ int stat;
char **args = AskMCDInfo(info, MACHINE, TRUE);
if (!args)
{
int CheckAndRemoveFromCluster(char *name, Bool ask_user)
{
- register int stat, ret_value;
+ int stat, ret_value;
Bool delete_it;
char *args[10], temp_buf[BUFSIZ], *ptr;
struct qelem *top, *elem = NULL;
static void RealDeleteMachine(char **info, Bool one_machine)
{
- register int stat;
+ int stat;
char temp_buf[BUFSIZ];
sprintf(temp_buf, "Are you sure you want to delete the machine %s (y/n)? ",
static void RealRemoveMachineFromCluster(char **info, Bool one_map)
{
char temp_buf[BUFSIZ];
- register int stat;
+ int stat;
sprintf(temp_buf, "Remove %s from the cluster %s",
info[MAP_MACHINE], info[MAP_CLUSTER]);
{
struct qelem *elem = NULL;
char buf[BUFSIZ], * args[10];
- register int stat;
+ int stat;
args[MAP_MACHINE] = canonicalize_hostname(strsave(argv[1]));
if (strcasecmp(args[MAP_MACHINE], argv[1]) && *argv[1] != '"')
static void RealUpdateSubnet(char **info, Bool junk)
{
- register int stat;
+ int stat;
char **args = AskMCDInfo(info, SUBNET, TRUE);
if (!args)
{
static void RealDeleteSubnet(char **info, Bool one_subnet)
{
- register int stat;
+ int stat;
char temp_buf[BUFSIZ];
sprintf(temp_buf,
static void RealUpdateCluster(char **info, Bool junk)
{
- register int stat;
+ int stat;
char **args = AskMCDInfo(info, CLUSTER, TRUE);
if (!args)
int CheckAndRemoveMachines(char *name, Bool ask_first)
{
- register int stat, ret_value;
+ int stat, ret_value;
Bool delete_it;
char *args[10], temp_buf[BUFSIZ], *ptr;
struct qelem *top, *elem = NULL;
static void RealDeleteCluster(char **info, Bool one_cluster)
{
- register int stat;
+ int stat;
char temp_buf[BUFSIZ];
sprintf(temp_buf,
static void RealRemoveClusterData(char **info, Bool one_item)
{
- register int stat;
+ int stat;
char *temp_ptr;
Put_message(" ");
struct qelem *local;
char *args[10], temp_buf[BUFSIZ];
int lists;
- register int status;
+ int status;
args[0] = type;
args[1] = name;
{
char buf[BUFSIZ];
struct qelem *top, *list;
- register int status;
+ int status;
Bool one_list;
list = NULL;
{
char *args[2];
struct qelem *elem = NULL;
- register int status;
+ int status;
switch (type)
{
static void RealUpdateList(char **info, Bool junk)
{
- register int stat;
+ int stat;
char **args;
struct qelem *elem = NULL;
{
char temp_buf[BUFSIZ];
char *list_name = argv[1];
- register int stat;
+ int stat;
if (!ValidName(list_name))
return DM_QUIT;
int ListMembersByType(char *type)
{
char temp_buf[BUFSIZ];
- register int status;
+ int status;
char *args[10];
args[0] = current_list;
int AddMember(void)
{
char *args[10], temp_buf[BUFSIZ], *p;
- register int status;
+ int status;
struct qelem *mailhubs, *elem, *GetTypeValues();
if (GetMemberInfo("add", args) == SUB_ERROR)
int DeleteMember(void)
{
char *args[10];
- register int status;
+ int status;
if (GetMemberInfo("delete", args) == SUB_ERROR)
return DM_NORMAL;
int InterRemoveItemFromLists(void)
{
- register int status;
+ int status;
char *type, *name, *args[10], buf[BUFSIZ];
struct qelem *top, *elem;
int ListAllPublicMailLists(void)
{
- register int status;
+ int status;
static char *args[] = {
"TRUE", /* active */
"TRUE", /* public */
int Start_menu(Menu *m)
{
struct menu_screen *make_ms();
- register void (*old_hook)(const char *, long, const char *, va_list) =
+ void (*old_hook)(const char *, long, const char *, va_list) =
set_com_err_hook((void (*) (const char *, long, const char *, va_list))menu_com_err_hook);
if (initscr() == (WINDOW *)ERR)
int ShowNFSService(int argc, char **argv)
{
- register int stat;
+ int stat;
struct qelem *elem = NULL;
char *args[10];
static void RealUpdateNFSService(char **info, Bool junk)
{
char **args;
- register int stat;
+ int stat;
if (!(args = AskNFSInfo(info)))
{
int UpdateNFSService(int argc, char **argv)
{
- register int stat;
+ int stat;
struct qelem *elem = NULL;
char *args[10];
{
char temp_buf[BUFSIZ], *args[10];
struct qelem *elem = NULL;
- register int stat;
+ int stat;
sprintf(temp_buf,
"Are you sure that you want to delete the %s directory on %s",
int DeleteNFSService(int argc, char **argv)
{
- register int stat;
+ int stat;
struct qelem *elem = NULL;
char *args[10];
static int PrintPOMachines(void)
{
- register int status;
+ int status;
static char *args[] = {"pop", NULL};
struct qelem *top = NULL;
int GetUserPOBox(int argc, char **argv)
{
- register int status;
+ int status;
struct qelem *top = NULL;
char buf[BUFSIZ];
int SetUserPOBox(int argc, char **argv)
{
- register int status;
+ int status;
char *type, temp_buf[BUFSIZ], *local_user, *args[10], box[BUFSIZ];
char *temp_box;
struct qelem *top = NULL;
int RemoveUserPOBox(int argc, char **argv)
{
- register int status;
+ int status;
char temp_buf[BUFSIZ];
if (!ValidName(argv[1]))
static char *GetDefaultUserQuota(Bool override)
{
- register int status;
+ int status;
char **info;
struct qelem *top = NULL;
static char *val[] = {"def_quota", NULL};
int ChangeDefaultQuota(int argc, char *argv[])
{
- register int status;
+ int status;
char temp_buf[BUFSIZ];
static char *newval[] = {
"def_quota", NULL, NULL
int GetQuota(void)
{
struct qelem *top = NULL;
- register int status;
+ int status;
char **args;
if (!(args = GetQuotaArgs(FALSE)))
int GetQuotaByFilesys(void)
{
struct qelem *top = NULL;
- register int status;
+ int status;
char **args = malloc(2 * sizeof(char *));
if (!args)
int AddQuota(void)
{
char **args;
- register int status;
+ int status;
if (!(args = GetQuotaArgs(TRUE)))
return DM_NORMAL;
static void RealUpdateQuota(char **info)
{
- register int status;
+ int status;
char temp_buf[BUFSIZ];
sprintf(temp_buf, "New quota for filesystem %s (in KB)", info[Q_FILESYS]);
static void RealDeleteQuota(char **info, Bool one_item)
{
- register int status;
+ int status;
char temp_buf[BUFSIZ];
if (!strcmp(info[Q_TYPE], "ANY"))
int DeleteQuota(void)
{
- register int status;
+ int status;
char **args;
struct qelem *top = NULL;
struct qelem *GetUserInfo(int type, char *name1, char *name2)
{
char *args[2];
- register int status;
+ int status;
struct qelem *elem = NULL;
switch (type)
int AddNewUser(void)
{
- register int status;
+ int status;
char **args, *info[MAX_ARGS_SIZE];
if (!(args = AskUserInfo(SetUserDefaults(info), FALSE)))
static char *GetUidNumberFromName(void)
{
char *args[5], *uid, first[BUFSIZ], last[BUFSIZ];
- register int status;
+ int status;
struct qelem *top = NULL;
if (!Prompt_input("First Name: ", first, BUFSIZ))
char *args[MAX_ARGS_SIZE];
char *login, *fstype = NULL;
char temp_buf[BUFSIZ];
- register int status;
+ int status;
Put_message("This function has NO kerberos support, so strange things");
Put_message("may happen if you use it to register a user.");
static void RealUpdateUser(char **info, Bool junk)
{
- register int status;
+ int status;
char error_buf[BUFSIZ];
char **args = AskUserInfo(info, TRUE);
static void RealDeactivateUser(char **info, Bool one_item)
{
- register int status;
+ int status;
char txt_buf[BUFSIZ];
char *qargs[2], **args;
struct qelem *elem = NULL;
void SlipInNewName(char **info, char *name)
{
- register int i;
+ int i;
/* This also pushes the NULL down. */
for (i = CountArgs(info); i > 0; i--)
char *Strsave(char *str)
{
- register char *newstr = malloc(strlen(str) + 1);
+ char *newstr = malloc(strlen(str) + 1);
if (!newstr)
return NULL;
int Print(int argc, char **argv, char *callback)
{
char buf[BUFSIZ];
- register int i;
+ int i;
found_some = TRUE;
strcpy(buf, argv[0]); /* no newline 'cause Put_message adds one */
int PrintHelp(char **message)
{
- register int i;
+ int i;
for (i = 0; i < CountArgs(message); i++)
Put_message(message[i]);
unsigned listsize;
char *cmp();
-int number(register char c, FILE *f);
+int number(char c, FILE *f);
/* This routine will determine if registration is enabled at this time. If
* NULL is returned, registration is OK. Otherwise, the string returned
char *disabled(char **msg)
{
- register char *cp;
+ char *cp;
int hit;
*msg = 0;
char *cmp(char *p, int v)
{
- register char *cp;
+ char *cp;
cp = p;
switch (*cp++)
append(char *fn)
{
- register int i, c;
- register char *cp;
- register char *ocp;
- register int n;
+ int i, c;
+ char *cp;
+ char *ocp;
+ int n;
FILE *f, *fopen();
if (!(f = fopen(fn, "r")))
goto loop;
}
-int number(register char c, FILE *f)
+int number(char c, FILE *f)
{
- register int n = 0;
+ int n = 0;
while (isdigit(c))
{
int call = ntohl((u_long)UREG_VERIFY_USER);
des_cblock key;
des_key_schedule ks;
- register char *bp = buf;
- register int len;
+ char *bp = buf;
+ int len;
char crypt_src[1024];
memcpy(bp, &version, sizeof(int));
int call = ntohl(opcode);
des_cblock key;
des_key_schedule ks;
- register char *bp = buf;
- register int len;
+ char *bp = buf;
+ int len;
char crypt_src[1024];
char *cbp;
int main(int argc, char **argv)
{
- register int ntimes;
- register int reencrypt;
+ int ntimes;
+ int reencrypt;
char line[100], *when, *msg;
int status;
char tmpfirst[100], tmplast[100], tmpmid[100];
/* do the database lookup */
char line[100];
- register int result;
+ int result;
if (user_is_valid)
{
gmitid(void)
{
/* get mid id */
- register int i;
+ int i;
char buf[15];
- register char *nbuf = buf;
+ char *nbuf = buf;
struct sigaction act;
input_mit_id:
#define _toupper(c) ((c) & ~0x20)
#endif
-int lenient_strcmp(register char *string1, register char *string2)
+int lenient_strcmp(char *string1, char *string2)
{
/*
* a primitive case insensitive string comparison. It returns only 0
longjmp(redo, 1);
}
-canon_name(register char *cp)
+canon_name(char *cp)
{
- register char *p2 = cp;
+ char *p2 = cp;
/* Trim whitespace off both ends. */
for (; *p2 && isspace(*p2); p2++)
insert_list(m)
struct member *m;
{
- register struct member_list *l, *l1;
+ struct member_list *l, *l1;
l = (struct member_list *) hash_lookup(lists, m->list_id);
if (l == NULL) {
insert_member(m)
struct member *m;
{
- register struct member_list *l, *l1;
+ struct member_list *l, *l1;
l = (struct member_list *) hash_lookup(members, m->member_id);
if (l == NULL) {
int listid;
int memberid;
{
- register struct member_list *l;
+ struct member_list *l;
for (l = (struct member_list *) hash_lookup(lists, listid); l; l = l->next)
if (l->member->member_id == memberid)
char *mtype;
EXEC SQL END DECLARE SECTION;
char buf[2];
- register struct member *m;
+ struct member *m;
for (; l; l = l->next) {
m = l->member;
struct member *allocmember()
{
- register struct member *m;
+ struct member *m;
m = (struct member *) malloc(sizeof(struct member));
if (m == NULL) {
int isinchain(m, l)
struct member *m;
-register struct member_list *l;
+struct member_list *l;
{
for (; l; l = l->next)
if (l->member == m)
int chainlen(l)
-register struct member_list *l;
+struct member_list *l;
{
- register int i;
+ int i;
for (i = 0; l; l = l->next, i++);
return(i);
}
* the key, or NULL (thus NULL is not a very good value to store...)
*/
-int int_hash_lookup(struct int_hash *h, register int key)
+int int_hash_lookup(struct int_hash *h, int key)
{
- register struct int_bucket *b;
+ struct int_bucket *b;
b = h->data[int_hash_func(h, key)];
while (b && b->key != key)
* existed, or 0 if not.
*/
-int int_hash_update(struct int_hash *h, register int key, int value)
+int int_hash_update(struct int_hash *h, int key, int value)
{
- register struct int_bucket *b;
+ struct int_bucket *b;
b = h->data[int_hash_func(h, key)];
while (b && b->key != key)
* previously there, 1 if it was, or -1 if we ran out of memory.
*/
-int int_hash_store(struct int_hash *h, register int key, int value)
+int int_hash_store(struct int_hash *h, int key, int value)
{
- register struct int_bucket *b, **p;
+ struct int_bucket *b, **p;
p = &(h->data[int_hash_func(h, key)]);
if (!*p)
* data with that value, call the callback proc with the corresponding key.
*/
-int int_hash_search(struct int_hash *h, register int value, void (*callback)())
+int int_hash_search(struct int_hash *h, int value, void (*callback)())
{
- register struct int_bucket *b, **p;
+ struct int_bucket *b, **p;
for (p = &(h->data[h->size - 1]); p >= h->data; p--)
{
int int_hash_step(struct int_hash *h, void (*callback)(), char *hint)
{
- register struct int_bucket *b, **p;
+ struct int_bucket *b, **p;
for (p = &(h->data[h->size - 1]); p >= h->data; p--)
{
int int_hash_destroy(struct int_hash *h)
{
- register struct int_bucket *b, **p, *b1;
+ struct int_bucket *b, **p, *b1;
for (p = &(h->data[h->size - 1]); p >= h->data; p--)
{
}
-check_fs(int id, register struct filesys *f, int hint)
+check_fs(int id, struct filesys *f, int hint)
{
EXEC SQL BEGIN DECLARE SECTION;
int iid = id, id1, id2, id3, rowcount;
struct string *string_check(int id)
{
- register struct string *s;
+ struct string *s;
s = (struct string *) hash_lookup(strings, id);
if (!s)
FILE *iout, *gout, *lout;
char ioutf[64], goutf[64], loutf[64], buf[2048], *l;
struct hash *groups;
- register struct bucket *b, **p;
+ struct bucket *b, **p;
struct grp *g;
struct user *u;
struct stat isb, gsb, lsb;
{
FILE *out;
char outf[64], outft[64], *mach, *group;
- register char *p;
+ char *p;
struct stat sb;
time_t ftime;
struct save_queue *sq, *sq2, *sq_create();
char name[129], type[9], fname[17], mname[17], lname[17], buf[257];
EXEC SQL END DECLARE SECTION;
char *s;
- register struct user *u;
+ struct user *u;
struct list *l, *memberlist;
- register struct member *m;
+ struct member *m;
/* The following is declarative, not executed,
* and so is dependent on where it is in the file,
save_mlist(int id, struct list *l, int force)
{
- register struct member *m;
- register struct list *l1;
+ struct member *m;
+ struct list *l1;
if (l->maillist > 1 || (l->maillist == 0 && !force))
return;
insert_name(char *s, int id, int nodups, int copy)
{
int code;
- register struct names *ns;
+ struct names *ns;
incount++;
code = hashstr(s);
/* While hashing the string, punt any illegal characters */
-int hashstr(register char *s)
+int hashstr(char *s)
{
- register int result;
- register int c;
+ int result;
+ int c;
for (result = 0; c = *s; s++)
{
if (illegalchars[c])
{
- register char *p;
+ char *p;
for (p = s; *p; p++)
*p = p[1];
continue;
output_data(int dummy, struct names *nms, FILE *out)
{
- register struct names *ns;
- register struct user *u;
+ struct names *ns;
+ struct user *u;
incount++;
for (ns = nms; ns; ns = ns->next)
int lwid, bol, awid;
-output_mlist(int id, register struct list *l)
+output_mlist(int id, struct list *l)
{
struct list *l1;
- register struct member *m;
- register struct user *u;
+ struct member *m;
+ struct user *u;
put_fill(out, l->description);
if (l->acl_t == 'L' && (l1 = (struct list *) hash_lookup(lists, l->acl_id)))
/* print out strings separated by commas, doing line breaks as appropriate */
-do_member(FILE *out, register char *s)
+do_member(FILE *out, char *s)
{
- register wwid;
+ wwid;
static int cont = 1;
char str[8];
}
-put_fill(FILE *aliases, register char *string)
+put_fill(FILE *aliases, char *string)
{
- register char *c;
- register int lwid;
- register int wwid;
+ char *c;
+ int lwid;
+ int wwid;
if (!string || !*string)
return;
{
static char *pool = NULL;
static unsigned pool_size = 0;
- register char *ret;
+ char *ret;
if (size > pool_size)
{
*/
char *pstrsave(char *s)
{
- register int len;
- register char *p;
+ int len;
+ char *p;
/* Kludge for sloppy string semantics */
if (!s)
{
* the key, or NULL (thus NULL is not a very good value to store...)
*/
-char *hash_lookup(struct hash *h, register int key)
+char *hash_lookup(struct hash *h, int key)
{
- register struct bucket *b;
+ struct bucket *b;
b = h->data[hash_func(h, key)];
while (b && b->key != key)
* existed, or 0 if not.
*/
-int hash_update(struct hash *h, register int key, char *value)
+int hash_update(struct hash *h, int key, char *value)
{
- register struct bucket *b;
+ struct bucket *b;
b = h->data[hash_func(h, key)];
while (b && b->key != key)
* there, 1 if it was, or -1 if we ran out of memory.
*/
-int hash_store(struct hash *h, register int key, char *value)
+int hash_store(struct hash *h, int key, char *value)
{
- register struct bucket *b, **p;
+ struct bucket *b, **p;
p = &(h->data[hash_func(h, key)]);
if (!*p)
* data with that value, call the callback proc with the corresponding key.
*/
-hash_search(struct hash *h, register char *value, void (*callback)())
+hash_search(struct hash *h, char *value, void (*callback)())
{
- register struct bucket *b, **p;
+ struct bucket *b, **p;
for (p = &(h->data[h->size - 1]); p >= h->data; p--)
{
hash_step(struct hash *h, void (*callback)(), char *hint)
{
- register struct bucket *b, **p;
+ struct bucket *b, **p;
for (p = &(h->data[h->size - 1]); p >= h->data; p--)
{
get_device(char *device_or_dir)
{
- register struct mntent *mntp;
+ struct mntent *mntp;
FILE *fstab;
fstab = setmntent(MNTTAB, "r");
}
-char *dequote(register char *s)
+char *dequote(char *s)
{
char *last = s;
do_list(char **before, int beforec, char **after, int afterc)
{
- register int agid, bgid;
+ int agid, bgid;
int ahide, bhide;
long code, id;
char g1[PR_MAXNAMELEN], g2[PR_MAXNAMELEN];
char *a6, char *a7, char *a8)
{
static int initd = 0;
- register long code;
- register int tries = 0;
+ long code;
+ int tries = 0;
check_afs();
int main(int argc, char **argv)
{
char realm[REALM_SZ + 1];
- register int code;
+ int code;
int i, lifetime = 1;
char srvtab[MAXPATHLEN + 1];
char *canonicalize_hostname(char *host)
{
- register struct hostent *hp;
+ struct hostent *hp;
int n_len;
int has_dot = 0;
char tbuf[BUFSIZ];
struct utsname name;
- register char *cp;
+ char *cp;
if (strlen(host) > 2 && host[0] == '"' && host[strlen(host) - 1] == '"')
{
/* can't get name from nameserver; fix up the format a bit */
for (cp = host; *cp; cp++)
{
- register int c; /* pcc doesn't like register char */
+ int c;
if (islower(c = *cp))
*cp = toupper(c);
has_dot |= (c == '.');
strncpy(first, ifnm, FIRST_LEN);
}
-FixCase(register char *p)
+FixCase(char *p)
{
- register int cflag; /* convert to lcase, unless at start or following */
- /* a space or punctuation mark (e.g., '-') */
+ int cflag; /* convert to lcase, unless at start or following */
+ /* a space or punctuation mark (e.g., '-') */
for (cflag = 0; *p; p++)
{
}
}
-LookForJrAndIII(register char *nm, register int *pends_jr, int *pends_ii,
- register int *pends_iii, register int *pends_iv,
- int *pends_v)
+LookForJrAndIII(char *nm, int *pends_jr, int *pends_ii, int *pends_iii,
+ int *pends_iv, int *pends_v)
{
- register int len = strlen(nm);
+ int len = strlen(nm);
if (len >= 4 && !strcmp(nm + len - 3, " JR"))
{
}
}
-LookForSt(register char *nm) /* ST PIERRE, etc. */
+LookForSt(char *nm) /* ST PIERRE, etc. */
{
char temp[256];
}
}
-LookForO(register char *nm) /* O BRIEN, etc. */
+LookForO(char *nm) /* O BRIEN, etc. */
{
if (!strcmp(nm, "O ") && isalpha(nm[2]))
nm[1] = '\'';
}
-TrimTrailingSpace(register char *ip)
+TrimTrailingSpace(char *ip)
{
- register char *p;
+ char *p;
for (p = ip + strlen(ip) - 1; p >= ip && isspace(*p); p--)
*p = '\0';
}
-GetMidInit(register char *nm, register char *mi)
+GetMidInit(char *nm, char *mi)
{
while (*nm && !isspace(*nm))
nm++;
* the key, or NULL (thus NULL is not a very good value to store...)
*/
-char *hash_lookup(struct hash *h, register int key)
+char *hash_lookup(struct hash *h, int key)
{
- register struct bucket *b;
+ struct bucket *b;
b = h->data[hash_func(h, key)];
while (b && b->key != key)
* existed, or 0 if not.
*/
-int hash_update(struct hash *h, register int key, char *value)
+int hash_update(struct hash *h, int key, char *value)
{
- register struct bucket *b;
+ struct bucket *b;
b = h->data[hash_func(h, key)];
while (b && b->key != key)
* there, 1 if it was, or -1 if we ran out of memory.
*/
-int hash_store(struct hash *h, register int key, char *value)
+int hash_store(struct hash *h, int key, char *value)
{
- register struct bucket *b, **p;
+ struct bucket *b, **p;
p = &(h->data[hash_func(h, key)]);
if (!*p)
* data with that value, call the callback proc with the corresponding key.
*/
-hash_search(struct hash *h, register char *value, void (*callback)())
+hash_search(struct hash *h, char *value, void (*callback)())
{
- register struct bucket *b, **p;
+ struct bucket *b, **p;
for (p = &(h->data[h->size - 1]); p >= h->data; p--)
{
hash_step(struct hash *h, void (*callback)(), char *hint)
{
- register struct bucket *b, **p;
+ struct bucket *b, **p;
for (p = &(h->data[h->size - 1]); p >= h->data; p--)
{
hash_destroy(struct hash *h)
{
- register struct bucket *b, **p, *b1;
+ struct bucket *b, **p, *b1;
for (p = &(h->data[h->size - 1]); p >= h->data; p--)
{
*/
int mr_access(char *name, int argc, char **argv)
{
- register char **nargv = malloc(sizeof(char *) * (argc + 1));
- register int status = 0;
+ char **nargv = malloc(sizeof(char *) * (argc + 1));
+ int status = 0;
nargv[0] = name;
memcpy(nargv + 1, argv, sizeof(char *) * argc);
{
int status;
mr_params params_st;
- register mr_params *params = NULL;
+ mr_params *params = NULL;
mr_params *reply = NULL;
CHECK_CONNECTED;
int mr_auth(char *prog)
{
- register int status;
+ int status;
mr_params params_st;
char *args[2];
int argl[2];
char realm[REALM_SZ], host[BUFSIZ], *p;
- register mr_params *params = ¶ms_st;
+ mr_params *params = ¶ms_st;
mr_params *reply = NULL;
KTEXT_ST auth;
return errno;
if (connection_status(_mr_conn) == CON_STOPPED)
{
- register status = connection_errno(_mr_conn);
+ int status = connection_errno(_mr_conn);
if (!status)
status = MR_CANT_CONNECT;
mr_disconnect();
}
int mr_start_send(OPERATION op, HALF_CONNECTION hcon,
- register struct mr_params *arg)
+ struct mr_params *arg)
{
int i, len;
unsigned int mr_size;
char *cp;
int *ip;
int i;
- register mr_params *arg = *argp;
+ mr_params *arg = *argp;
while (!done)
{
int mr_start_recv(OPERATION op, HALF_CONNECTION hcon, struct mr_params **argp)
{
- register mr_params *arg = *argp;
+ mr_params *arg = *argp;
if (!arg)
{
*argp = arg = malloc(sizeof(mr_params));
int mr_query(char *name, int argc, char **argv,
int (*callproc)(), char *callarg)
{
- register char **nargv = malloc(sizeof(char *) * (argc + 1));
- register int status = 0;
+ char **nargv = malloc(sizeof(char *) * (argc + 1));
+ int status = 0;
nargv[0] = name;
memcpy(nargv + 1, argv, sizeof(char *) * argc);
{
int status;
mr_params params_st;
- register mr_params *params = NULL;
+ mr_params *params = NULL;
mr_params *reply = NULL;
int stopcallbacks = 0;
char *format_filesys_type(char *fs_status)
{
char buf[BUFSIZ];
- register struct pair *pp;
+ struct pair *pp;
int n_names = 0;
int stat = atoi(fs_status);
*/
char *parse_filesys_type(char *fs_type_name)
{
- register struct pair *pp;
- register char *cp = fs_type_name;
+ struct pair *pp;
+ char *cp = fs_type_name;
char temp[BUFSIZ];
int flags = 0;
struct save_queue *sq_create(void)
{
- register struct save_queue *sq;
+ struct save_queue *sq;
sq = malloc(sizeof(struct save_queue));
if (!sq)
return sq;
}
-int sq_save_data(register struct save_queue *sq, char *data)
+int sq_save_data(struct save_queue *sq, char *data)
{
- register struct save_queue *q;
+ struct save_queue *q;
q = malloc(sizeof(struct save_queue));
if (!q)
return 1;
}
-int sq_save_args(register int argc, register char *argv[],
- register struct save_queue *sq)
+int sq_save_args(int argc, char *argv[], struct save_queue *sq)
{
- register char **argv_copy;
- register int i;
- register int n;
+ char **argv_copy;
+ int i, n;
argv_copy = malloc(argc * sizeof(char *));
if (!argv_copy)
return sq_save_data(sq, (char *)argv_copy);
}
-int sq_save_unique_data(register struct save_queue *sq, char *data)
+int sq_save_unique_data(struct save_queue *sq, char *data)
{
- register struct save_queue *q;
+ struct save_queue *q;
for (q = sq->q_next; q != sq; q = q->q_next)
{
return sq_save_data(sq, data);
}
-int sq_save_unique_string(register struct save_queue *sq, char *data)
+int sq_save_unique_string(struct save_queue *sq, char *data)
{
- register struct save_queue *q;
+ struct save_queue *q;
for (q = sq->q_next; q != sq; q = q->q_next)
{
return sq_save_data(sq, data);
}
-int sq_get_data(register struct save_queue *sq, register char **data)
+int sq_get_data(struct save_queue *sq, char **data)
{
if (sq->q_lastget == (struct save_queue *)0)
sq->q_lastget = sq->q_next;
return 1;
}
-int sq_remove_data(register struct save_queue *sq, register char **data)
+int sq_remove_data(struct save_queue *sq, char **data)
{
if (sq->q_next != sq)
{
return 0;
}
-int sq_empty(register struct save_queue *sq)
+int sq_empty(struct save_queue *sq)
{
if (sq->q_next == sq)
return 1;
return 0;
}
-sq_destroy(register struct save_queue *sq)
+sq_destroy(struct save_queue *sq)
{
- register struct save_queue *q;
+ struct save_queue *q;
for (q = sq->q_next; q != sq; q = sq->q_next)
{
*/
char *strsave(char *s)
{
- register int len;
- register char *p;
+ int len;
+ char *p;
/* Kludge for sloppy string semantics */
if (!s)
{
/*
* Trim whitespace off both ends of a string.
*/
-char *strtrim(register char *save)
+char *strtrim(char *save)
{
- register char *t, *s;
+ char *t, *s;
s = save;
while (isspace(*s))
char *uppercase(char *s)
{
- register char *p;
+ char *p;
for (p = s; *p; p++)
{
char *lowercase(char *s)
{
- register char *p;
+ char *p;
for (p = s; *p; p++)
{
int status = SUCCESS; /* General purpose error status */
char fstype_buf[7]; /* Buffer to hold fs_type, a 16 bit number */
char *login; /* The login name the user wants */
- register int i; /* A counter */
+ int i; /* A counter */
/* Log that we are about to reserve a user. */
com_err(whoami, 0, "reserving user %s %s", message->first, message->last);
int status = SUCCESS; /* General purpose error status */
char fstype_buf[7]; /* Buffer to hold fs_type, a 16 bit number */
char *login; /* The login name the user wants */
- register int i; /* A counter */
+ int i; /* A counter */
/* Log that we are about to reserve a user. */
com_err(whoami, 0, "setting identity %s %s",
void req_initialize(void)
{
- register int i;
+ int i;
/* Get service information from /etc/services */
if (!(sp = getservbyname("sms_ureg", "udp")))
int handle_retransmitted(void)
{
- register int i; /* A counter */
+ int i; /* A counter */
int status = FALSE; /* Return status */
for (i = PREV_INDEX(cur_request_index); i != cur_request_index;
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
};
-int ureg_validate_char(register char *s)
+int ureg_validate_char(char *s)
{
while (*s)
{
#include <stdio.h>
#include <ctype.h>
-FixCase(register char *p)
+FixCase(char *p)
{
- register int cflag;
+ int cflag;
for (cflag = 0; *p; p++)
{
}
}
-LookForJrAndIII(register char *nm, register int *pends_sr,
- register int *pends_jr, register int *pends_iii,
- register int *pends_iv)
+LookForJrAndIII(char *nm, int *pends_sr, int *pends_jr, int *pends_iii,
+ int *pends_iv)
{
- register int len = strlen(nm);
+ int len = strlen(nm);
if (len >= 4 && !strcmp(nm + len - 3, " SR"))
{
}
}
-LookForSt(register char *nm) /* ST PIERRE, etc. */
+LookForSt(char *nm) /* ST PIERRE, etc. */
{
char temp[256];
}
}
-LookForO(register char *nm) /* O BRIEN, etc. */
+LookForO(char *nm) /* O BRIEN, etc. */
{
if (!strcmp(nm, "O ") && isalpha(nm[2]))
nm[1] = '\'';
int hashname(char *name, enum tables type)
{
- register int val = type;
+ int val = type;
while (*name)
val = (val << 5) - val + *name++ - '`';
void flush_cache(void)
{
- register struct item *i;
+ struct item *i;
if (cachehits + cachemisses != 0)
{
int name_to_id(char *name, enum tables type, int *id)
{
- register struct item *i, *t;
+ struct item *i, *t;
EXEC SQL BEGIN DECLARE SECTION;
char *iname;
int j, h;
int id_to_name(int id, enum tables type, char **name)
{
- register struct item *i, *t;
+ struct item *i, *t;
EXEC SQL BEGIN DECLARE SECTION;
char iname[NAMESZ];
int j;
int cache_entry(char *name, enum tables type, int id)
{
- register struct item *i, *t;
+ struct item *i, *t;
for (i = cachehead.next; i != &cachehead; i = i->next)
{
void flush_name(char *name, enum tables type)
{
- register struct item *i;
+ struct item *i;
/* first clear it out of the transaction chain */
for (i = &cachehead; i && i->trans; i = i->trans)
void cache_abort(void)
{
- register struct item *i, *t;
+ struct item *i, *t;
for (i = cachehead.trans; i; i = t)
{
int mr_connect(char *server)
{
- register int status;
+ int status;
extern int query_timeout;
struct sigaction action;
int trigger_dcm(int dummy0, int dummy1, client *cl)
{
- register int pid, status;
+ int pid, status;
char prog[128];
if ((status = check_query_access(&pseudo_query, 0, cl)))
*/
while (!takedown)
{
- register int i;
+ int i;
/*
* Block until something happens.
*/
*/
int new_connection(void)
{
- register client *cp;
+ client *cp;
static counter = 0;
/*
void oplist_delete(LIST_OF_OPERATIONS oplp, OPERATION op)
{
- register OPERATION *s;
- register int c;
+ OPERATION *s;
+ int c;
for (s = oplp->op, c = oplp->count; c; --c, ++s)
{
free_rtn_tuples(client *cp)
{
- register returned_tuples *temp;
+ returned_tuples *temp;
for (temp = cp->first; temp && OP_DONE(temp->op); )
{
- register returned_tuples *t1 = temp;
+ returned_tuples *t1 = temp;
temp = t1->next;
if (t1 == cp->last)
cp->last = NULL;
cp->first = temp;
}
-retr_callback(register int argc, register char **argv, char *p_cp)
+retr_callback(int argc, char **argv, char *p_cp)
{
- register client *cp = (client *)p_cp;
+ client *cp = (client *)p_cp;
mr_params *arg_tmp;
returned_tuples *tp;
OPERATION op_tmp;
- register char **nargv;
- register int i;
+ char **nargv;
+ int i;
if (row_count++ >= max_row_count)
{
arg_tmp->mr_argv = nargv;
for (i = 0; i < argc; i++)
{
- register int len = strlen(argv[i]) + 1;
+ int len = strlen(argv[i]) + 1;
nargv[i] = malloc(len);
memcpy(nargv[i], argv[i], len);
}
for (i = 0; i < nclients; i++)
{
- register client *cl = clients[i];
+ client *cl = clients[i];
if (cl->clname)
argv[0] = cl->clname;
else argv[0] = "unauthenticated";
return 0;
}
-do_retr(register client *cl)
+do_retr(client *cl)
{
- register char *queryname;
+ char *queryname;
cl->reply.mr_argc = 0;
cl->reply.mr_status = 0;
int trigger_dcm(int dummy0, int dummy1, client *cl)
{
- register int pid;
+ int pid;
char prog[128];
cl->reply.mr_argc = 0;
extern char *whoami;
-char *requote(char *buf, register char *cp, int len)
+char *requote(char *buf, char *cp, int len)
{
- register int count = 0;
- register unsigned char c;
+ int count = 0;
+ unsigned char c;
if (len <= 2)
return buf;
*buf++ = '"';
void log_args(char *tag, int version, int argc, char **argv)
{
char buf[BUFSIZ];
- register int i;
- register char *bp;
+ int i;
+ char *bp;
i = strlen(tag);
sprintf(buf, "%s[%d]: ", tag, version);
int mr_trim_args(int argc, char **argv)
{
- register char **arg;
- register unsigned char *p, *lastch;
+ char **arg;
+ unsigned char *p, *lastch;
for (arg = argv; argc--; arg++)
{
struct validate *v, int (*action)(), int actarg,
client *cl)
{
- register int i, j;
+ int i, j;
char **argv;
int id, status;
int followup_guax(struct query *q, struct save_queue *sq, struct validate *v,
int (*action)(), int actarg, client *cl)
{
- register int i, j;
+ int i, j;
char **argv;
#ifdef GDSS
unsigned char sigbuf[256];
int followup_gqot(struct query *q, struct save_queue *sq, struct validate *v,
int (*action)(), int actarg, client *cl)
{
- register int j;
+ int j;
char **argv;
EXEC SQL BEGIN DECLARE SECTION;
int id;
int followup_gpce(struct query *q, struct save_queue *sq, struct validate *v,
int (*action)(), int actarg, client *cl)
{
- register int i, j;
+ int i, j;
char **argv;
int id, status;
int mr_open_database(void)
{
- register int i;
+ int i;
SQLDA *mr_alloc_sqlda();
static first_open = 1;
int mr_process_query(client *cl, char *name, int argc, char *argv_ro[],
int (*action)(), char *actarg)
{
- register struct query *q;
- register int status;
- register struct validate *v;
+ struct query *q;
+ int status;
+ struct validate *v;
char qual[256];
char sort[32];
char *pqual;
char *build_sort(struct validate *v, char *sort)
{
- register struct valobj *vo;
- register int n;
+ struct valobj *vo;
+ int n;
char elem[16];
n = v->objcnt;
int mr_verify_query(client *cl, struct query *q, int argc, char *argv_ro[])
{
- register int argreq;
- register int status;
- register struct validate *v = q->validate;
- register int i;
- register char *to, *fr, *stop;
+ int argreq;
+ int status;
+ struct validate *v = q->validate;
+ int i;
+ char *to, *fr, *stop;
privileged = 0;
char *sqlstrstr(char *str, char *pat)
{
- register char *p = pat;
+ char *p = pat;
do
{
}
if (*str == *p)
{
- register char *s;
+ char *s;
s = str;
while (*++p && (*++s == *p))
;
char *argv[], char *qual)
{
char fmt_buf[MR_STMTBUF_LEN];
- register char *res, *fmt;
+ char *res, *fmt;
if (qual)
sprintf(fmt_buf, "%s %s WHERE %s", cmd, targetlist, qual);
void sanity_check_queries(void)
{
- register int i;
+ int i;
int maxv = 0, maxa = 0;
extern int QueryCount2;
extern struct query Queries2[];
char dir[81];
int mid = mach_id;
EXEC SQL END DECLARE SECTION;
- register int status;
- register char *cp1;
- register char *cp2;
+ int status;
+ char *cp1;
+ char *cp2;
status = MR_NFS;
EXEC SQL DECLARE csr101 CURSOR FOR
extern struct query Queries2[];
extern int QueryCount2;
-struct query *get_query_by_name(register char *name, int version)
+struct query *get_query_by_name(char *name, int version)
{
- register struct query *q;
- register int i;
+ struct query *q;
+ int i;
q = Queries2;
i = QueryCount2;
void list_queries(int version, int (*action)(), char *actarg)
{
- register struct query *q;
- register int i;
+ struct query *q;
+ int i;
static struct query **squeries2 = NULL;
- register struct query **sq;
+ struct query **sq;
char qnames[80];
char *qnp;
int count;
(*action)(1, &qnp, actarg);
}
-void help_query(register struct query *q, int (*action)(), char *actarg)
+void help_query(struct query *q, int (*action)(), char *actarg)
{
- register int argcount;
- register int i;
+ int argcount;
+ int i;
char argn[32];
char qname[512];
char argr[512];
/* Validation Routines */
-int validate_row(register struct query *q, char *argv[], register struct validate *v)
+int validate_row(struct query *q, char *argv[], struct validate *v)
{
EXEC SQL BEGIN DECLARE SECTION;
char qual[128];
return MR_EXISTS;
}
-int validate_fields(struct query *q, register char *argv[],
- register struct valobj *vo, register int n)
+int validate_fields(struct query *q, char *argv[], struct valobj *vo, int n)
{
- register int status;
+ int status;
while (--n >= 0)
{
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
};
-int validate_chars(char *argv[], register struct valobj *vo)
+int validate_chars(char *argv[], struct valobj *vo)
{
char *s = argv[vo->index];
int arg;
}
-int validate_id(struct query *q, char *argv[], register struct valobj *vo)
+int validate_id(struct query *q, char *argv[], struct valobj *vo)
{
EXEC SQL BEGIN DECLARE SECTION;
char *name, *namefield, *idfield;
int id, rowcount, tbl;
EXEC SQL END DECLARE SECTION;
int status;
- register char *c;
+ char *c;
name = argv[vo->index];
tbl = vo->table;
}
}
-int validate_name(char *argv[], register struct valobj *vo)
+int validate_name(char *argv[], struct valobj *vo)
{
char *name, *namefield;
- register char *c;
+ char *c;
name = argv[vo->index];
namefield = vo->namefield;
int id;
EXEC SQL END DECLARE SECTION;
int status;
- register char *c;
+ char *c;
status = validate_chars(argv, vo);
if (status != MR_EXISTS)
}
-int validate_type(char *argv[], register struct valobj *vo)
+int validate_type(char *argv[], struct valobj *vo)
{
EXEC SQL BEGIN DECLARE SECTION;
char *typename;
char *val;
int cnt;
EXEC SQL END DECLARE SECTION;
- register char *c;
+ char *c;
typename = vo->namefield;
c = val = argv[vo->index];
/* validate member or type-specific data field */
-int validate_typedata(register struct query *q, register char *argv[], register struct valobj *vo)
+int validate_typedata(struct query *q, char *argv[], struct valobj *vo)
{
EXEC SQL BEGIN DECLARE SECTION;
char *name;
int id;
EXEC SQL END DECLARE SECTION;
int status;
- register char *c;
+ char *c;
/* get named object */
name = argv[vo->index];
/* Make sure the data fits in the field */
-int validate_len(register char *argv[], register struct valobj *vo)
+int validate_len(char *argv[], struct valobj *vo)
{
EXEC SQL BEGIN DECLARE SECTION;
int len;
SQLDA *mr_alloc_sqlda()
{
SQLDA *it;
- register int j;
+ int j;
it = sqlald(QMAXARGS, ARGLEN, 0);
if (!it)
int convert_wildcards(char *arg)
{
static char buffer[ARGLEN];
- register char *s, *d;
+ char *s, *d;
for (d = buffer, s = arg; *s; s++)
{
int convert_wildcards_uppercase(char *arg)
{
static char buffer[ARGLEN];
- register char *s, *d;
+ char *s, *d;
for (d = buffer, s = arg; *s; s++)
{
sprintf(buf, "auth for %s.%s@%s failed: %s",
ad.pname, ad.pinst, ad.prealm, error_message(code));
{
- register int rc;
+ int rc;
rc = send_object(conn, (char *)&code, INTEGER_T);
code = rc;
}
int checksum_file(char *path)
{
- register int sum;
- register int ch;
- register FILE *f;
+ int sum;
+ int ch;
+ FILE *f;
sum = 0;
f = fopen(path, "r");
KTEXT_ST ticket_st;
KTEXT ticket = &ticket_st;
STRING data;
- register int code;
+ int code;
int response;
int auth_version = 2;
{
int response;
STRING data;
- register int code;
+ int code;
string_alloc(&data, BUFSIZ);
sprintf(STRING_DATA(data), "EXEC_002 %s", path);
n_written = 0;
while (n_written < file_size)
{
- register int n_wrote;
+ int n_wrote;
n_wrote = write(fd, buf, sizeof(buf));
if (n_wrote == -1)
{
n = 0;
while (n < n_read)
{
- register int n_wrote;
+ int n_wrote;
n_wrote = write(fd, STRING_DATA(data) + n, n_read - n);
if (n_wrote == -1)
{
#define def(name, level, prio) \
name(char *msg)\
{\
- register int old_prio; \
+ int old_prio; \
old_prio = log_priority; \
mr_update_initialize(); \
com_err(whoami, 0, fmt, level, msg); \
int get_mr_update_ticket(char *host, KTEXT ticket)
{
- register int code;
- register int pass;
+ int code;
+ int pass;
char phost[BUFSIZ];
CREDENTIALS cr;
int get_mr_tgt(void)
{
- register int code;
+ int code;
char linst[INST_SZ], kinst[INST_SZ];
init();
/* got a connection; loop forever */
while (1)
{
- register char *cp;
+ char *cp;
code = receive_object(conn, (char *)&str, STRING_T);
if (code)
{