[moira.git] / reg_svr / reg_svr.pc

/* $Id$
 *
 * Server for user registration with Moira and Kerberos.
 *
 * Copyright (C) 1987-1998 by the Massachusetts Institute of Technology
 * For copying and distribution information, please see the file
 * <mit-copyright.h>.
 */

#include <mit-copyright.h>
#include <moira.h>
#include <mr_private.h>
#include <moira_schema.h>
#include <moira_site.h>
#include "reg_svr.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/utsname.h>

#include <netinet/in.h>
#include <netdb.h>

#include <ctype.h>
#include <errno.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <com_err.h>
#include <krb.h>

EXEC SQL INCLUDE sqlca;

RCSID("$Header$");

char *whoami, *hostname, *shorthostname;

char *find_usernames(char *first, char *middle, char *last);
void fixname(char *name);
int register_user(int uid, char *username);
void mr_com_err(const char *whoami, long code, const char *fmt, va_list pvar);
void sigshut(int);

reg_client *cl = NULL;
enum { RS_RUNNING, RS_SLEEPING, RS_EXITING } state = RS_RUNNING;

int main(int argc, char **argv)
{
  int listener, nfds, i, clientid = 0;
  fd_set readfds, xreadfds;
  reg_client *clients;
  int nclients, clientssize;
  long status;
  char *db = "moira";
  struct utsname uts;
  struct hostent *h;
  struct sigaction sa;
  struct stat st;

  whoami = strrchr(argv[0], '/');
  whoami = whoami ? whoami + 1 : argv[0];

  set_com_err_hook(mr_com_err);

  /* Read keys */
  if (!read_rsa_key())
    {
      com_err(whoami, errno, "reading RSA key");
      exit(1);
    }
  if (!read_hmac_key())
    {
      com_err(whoami, errno, "reading HMAC key");
      exit(1);
    }

  /* Read error messages */
  if (!read_errors())
    {
      com_err(whoami, errno, "reading error messages");
      exit(1);
    }

  /* Connect to database */
  EXEC SQL CONNECT :db IDENTIFIED BY :db;
  if (sqlca.sqlcode)
    {
      char err_msg[256];
      int bufsize = 256, msglength = 0;

      sqlglm(err_msg, &bufsize, &msglength);
      err_msg[msglength] = 0;
      com_err(whoami, 0, "SQL error connecting to DBMS:\n%s", err_msg);
      exit(1);
    }

  /* Get my hostname */
  uname(&uts);
  h = gethostbyname(uts.nodename);
  if (!h)
    {
      com_err(whoami, 0, "Couldn't resolve hostname %s", uts.nodename);
      exit(1);
    }
  hostname = lowercase(xstrdup(h->h_name));
  shorthostname = xstrdup(hostname);
  if (strchr(shorthostname, '.'))
    *strchr(shorthostname, '.') = '\0';

  /* Initialize kerberos */
  status = init_kerberos();
  if (status)
    {
      com_err(whoami, status, "initializing kerberos library");
      exit(1);
    }

  /* Set up listening socket. */
  listener = mr_listen("moira_ureg");
  if (listener < 0)
    {
      com_err(whoami, errno, "couldn't create listening socket");
      exit(1);
    }
  FD_ZERO(&xreadfds);
  FD_SET(listener, &xreadfds);
  nfds = listener + 1;

  /* Initialize client array. */
  nclients = 0;
  clientssize = 5;
  clients = malloc(clientssize * sizeof(reg_client));
  if (!clients)
    {
      com_err(whoami, errno, "creating client array");
      exit(1);
    }

  /* Set up signal handlers */
  sa.sa_flags = 0;
  sigemptyset(&sa.sa_mask);
  sa.sa_handler = sigshut;
  sigaction(SIGTERM, &sa, NULL);
  sigaction(SIGINT, &sa, NULL);
  sigaction(SIGHUP, &sa, NULL);
  sa.sa_handler = SIG_IGN;
  sigaction(SIGPIPE, &sa, NULL);

  com_err(whoami, 0, "started (pid %d)", getpid());
  com_err(whoami, 0, rcsid);

  /* Main loop */
  while (state != RS_EXITING)
    {
      if (state == RS_RUNNING && stat(MOIRA_MOTD_FILE, &st) == 0)
	{
	  state == RS_SLEEPING;
	  com_err(whoami, 0, "found motd. reg_svr is sleeping");
	}
      else if (state == RS_SLEEPING && stat(MOIRA_MOTD_FILE, &st) == -1)
	{
	  state == RS_RUNNING;
	  com_err(whoami, 0, "motd gone. reg_svr is running");
	}

      memcpy(&readfds, &xreadfds, sizeof(readfds));
      if (select(nfds, &readfds, NULL, NULL, NULL) == -1)
	{
	  if (errno != EINTR)
            com_err(whoami, errno, "in select");
	  continue;
	}

      if (FD_ISSET(listener, &readfds))
	{
	  int newconn, addrlen = sizeof(struct sockaddr_in);
	  struct sockaddr_in addr;

	  newconn = accept(listener, (struct sockaddr *)&addr, &addrlen);
	  if (newconn < 0)
	    com_err(whoami, errno, "accepting new connection");
	  else
	    {
	      nclients++;
	      if (nclients > clientssize)
		{
		  clientssize = 2 * clientssize;
		  clients = xrealloc(clients, clientssize *
				     sizeof(reg_client));
		}

	      cl = &clients[nclients - 1];
	      memset(cl, 0, sizeof(reg_client));
	      cl->fd = newconn;
	      cl->lastmod = time(NULL);
	      cl->clientid = ++clientid;
	      cl->random = init_rand(cl);
	      FD_SET(newconn, &xreadfds);
	      if (newconn >= nfds)
		nfds = newconn + 1;

	      com_err(whoami, 0,
		      "New connection from %s port %d (now %d client%s)",
		      inet_ntoa(addr.sin_addr), (int)ntohs(addr.sin_port),
		      nclients, nclients != 1 ? "s" : "");
	    }
	}

      for (i = 0; i < nclients; i++)
	{
	  cl = &clients[i];
	  if (FD_ISSET(cl->fd, &readfds))
	    {
	      cl->lastmod = time(NULL);
	      if (!cl->buf)
		{
		  /* We're just starting */
		  cl->buf = malloc(3);
                  if (!cl->buf)
		    {
		      com_err(whoami, errno, "allocating read buffer");
		      reply(cl, INTERNAL_ERROR, "INIT", "c", NULL,
			    "Out of memory");
		      goto reap;
		    }
		  cl->nread = 0;
		}

	      if (cl->nread < 3)
		{
		  /* We haven't read the length byte yet... */
		  cl->nread += read(cl->fd, cl->buf + cl->nread,
				    3 - cl->nread);
		  if (cl->nread == 3)
		    {
		      cl->nmax = cl->buf[1] * 256 + cl->buf[2] + 3;
		      cl->buf = realloc(cl->buf, cl->nmax + 3);
		      if (!cl->buf)
			{
			  com_err(whoami, errno, "reallocating read buffer");
			  reply(cl, INTERNAL_ERROR, "INIT", "c", NULL,
				"Out of memory");
			  goto reap;
			}
		    }
		  else if (cl->nread == 0)
		    {
		      /* client has closed connection. setting
			 lastmod will cause it to be reaped */
		      cl->lastmod = 0;
		    }
		}
	      else
		{
		  /* We know how long the packet is supposed to be */
		  cl->nread += read(cl->fd, cl->buf + cl->nread,
				    cl->nmax - cl->nread);
		  if (cl->nread == cl->nmax)
		    {
		      parse_packet(cl, cl->buf[0], cl->nread - 3, cl->buf + 3,
				   state == RS_SLEEPING);
		      free(cl->buf);
		      cl->buf = NULL;
		    }
		}
	    }

	reap:
	  if (cl->lastmod < time(NULL) - TIMEOUT)
	    {
	      com_err(whoami, 0, "Closed connection. (now %d client%s)",
		      nclients - 1, nclients != 2 ? "s" : "");
	      shutdown(cl->fd, 2);
	      close(cl->fd);
	      FD_CLR(cl->fd, &xreadfds);
	      free(cl->buf);
	      free(cl->id);
	      free(cl->username);
	      free(cl->suggestions);
	      free(cl->random);
	      clients[i] = clients[--nclients];
	      i--;
	    }
	}
      cl = NULL;
    }
  com_err(whoami, 0, "Exiting.");
}

void RIFO(reg_client *rc, int argc, char **argv)
{
  EXEC SQL BEGIN DECLARE SECTION;
  char *ufirst, *umiddle, *ulast, *id;
  char login[USERS_LOGIN_SIZE], first[USERS_FIRST_SIZE];
  char middle[USERS_MIDDLE_SIZE], last[USERS_LAST_SIZE];
  char fullname[USERS_FIRST_SIZE + USERS_MIDDLE_SIZE + USERS_LAST_SIZE];
  char class[USERS_TYPE_SIZE];
  int uid, status, secure, sqlstatus;
  EXEC SQL END DECLARE SECTION;

  if (rc->uid || argc != 4)
    {
      reply(rc, PROTOCOL_ERROR, "INIT", "c", NULL);
      return;
    }

  ufirst = argv[0];
  umiddle = argv[1];
  ulast = argv[2];
  id = argv[3];

  /* "ORDER BY status" so that if there's both a matching state 0 entry
     and a matching state 3 entry, we'll get the former. */
  EXEC SQL DECLARE csr_id CURSOR FOR
    SELECT login, unix_uid, status, secure, first, middle, last, type
    FROM users WHERE clearid = :id ORDER BY status;
  EXEC SQL OPEN csr_id;
  while (1)
    {
      EXEC SQL FETCH csr_id INTO :login, :uid, :status,
	:secure, :first, :middle, :last, :class;
      if (sqlca.sqlcode)
	break;
      strtrim(login);
      strtrim(first);
      strtrim(middle);
      strtrim(last);
      strtrim(class);

      /* Check names, allowing for the possibility that Moira and the
	 user might have them split up differently. eg, Mary/Ann/Singleton
	 vs. Mary Ann/Singleton. */
      if (strcasecmp(last, ulast) && strncasecmp(last, ulast, strlen(last)) &&
	  strncasecmp(last, ulast, strlen(ulast)))
	continue;
      if (strlen(last) > 3 && strlen(ulast) < 3)
	continue;
      if (strcasecmp(first, ufirst) &&
	  strncasecmp(first, ufirst, strlen(first)) &&
	  strncasecmp(first, ufirst, strlen(ufirst)))
	continue;
      if (strlen(first) > 3 && strlen(ufirst) < 3)
	continue;
      /* Ignore the middle name since Moira doesn't have those reliably */
      break;
    }
  sqlstatus = sqlca.sqlcode;
  EXEC SQL CLOSE csr_id;

  if (sqlstatus)
    {
      reply(rc, NOT_FOUND_IN_DATABASE, "GETN", "d", NULL);
      return;
    }

  switch (status)
    {
    case US_REGISTERED:
    case US_ENROLLED:
    case US_ENROLL_NOT_ALLOWED:
      reply(rc, ALREADY_REGISTERED, "INIT", "c", NULL, login);
      return;

    case US_DELETED:
      reply(rc, ACCOUNT_DELETED, "INIT", "c", NULL, login);
      return;

    case US_NOT_ALLOWED:
      reply(rc, NOT_ELIGIBLE, "INIT", "c", NULL);
      return;

    default:
      break;
    }

  rc->uid = uid;
  sprintf(fullname, "%s %s%s%s", first, middle, *middle ? " " : "", last);
  if (!strcmp(class, "MITS"))
    strcpy(class, "STAFF");
  if (secure == 1)
    {
      rc->id = strdup(id);
      if (!rc->id)
	{
	  com_err(whoami, errno, "in RIFO");
	  reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, "Out of memory");
	  return;
	}
    }
  if (*login != '#')
    {
      rc->reserved_username = 1;
      rc->username = strdup(login);
      if (!rc->username)
	{
	  com_err(whoami, errno, "in RIFO");
	  reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, "Out of memory");
	  return;
	}
    }
  else
    {
      rc->suggestions = find_usernames(first, middle, last);
      if (!rc->suggestions && errno)
	{
	  com_err(whoami, errno, "in RIFO");
	  reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, error_message(errno));
	  return;
	}
    }

  if (rc->id)
    reply(rc, FOUND, "GETW", "c", NULL, fullname, class);
  else if (!rc->username)
    reply(rc, FOUND, "GETL", "c", rc->suggestions, fullname, class);
  else
    reply(rc, FORCED_USERNAME, "GETP", "c", NULL, rc->username);
}

void SWRD(reg_client *rc, int argc, char **argv)
{
  char *words[6];
  int i;

  if (!rc->id || argc != 6)
    {
      reply(rc, PROTOCOL_ERROR, "INIT", "c", NULL);
      return;
    }

  getwordlist(rc->id, words);
  for (i = 0; i < 6; i++)
    {
      if (strcasecmp(strtrim(argv[i]), words[i]))
	break;
    }
  if (i != 6)
    {
      reply(rc, BAD_SIX_WORDS, "GETW", "d", NULL);
      return;
    }

  free(rc->id);
  rc->id = NULL;
  if (!rc->username)
    reply(rc, NO_MESSAGE, "GETL", "c", rc->suggestions);
  else
    reply(rc, FORCED_USERNAME, "GETP", "c", NULL, rc->username);
}

void LOGN(reg_client *rc, int argc, char **argv)
{
  int i;
  char *login;
  long status;

  if (!rc->uid || rc->id || rc->username || argc != 1)
    {
      reply(rc, PROTOCOL_ERROR, "INIT", "c", NULL);
      return;
    }

  login = argv[0];

  /* make sure someone's not trying to overrun reply */
  if (strlen(login) > 100)
    {
      com_err(whoami, 0, "Buffer overrun attempted? Closing connection");
      rc->lastmod = 0;
      return;
    }

  if ((strlen(login) < 3) || (strlen(login) > USERS_LOGIN_SIZE - 1) ||
      (login[0] == '_') || isdigit(login[0]))
    {
      reply(rc, BAD_USERNAME, "GETL", "c", rc->suggestions, login,
	    3, USERS_LOGIN_SIZE - 1);
      return;
    }

  for (i = 0; i < strlen(login); i++)
    {
      if (!islower(login[i]) && !isdigit(login[i]) && (login[i] != '_'))
	{
	  reply(rc, BAD_USERNAME, "GETL", "c", rc->suggestions, login,
		3, USERS_LOGIN_SIZE - 1);
	  return;
	}
    }

  status = check_kerberos(login);
  if (status == MR_SUCCESS)
    status = register_user(rc->uid, login);

  if (status == MR_IN_USE)
    {
      if (rc->reserved_username)
	{
	  reply(rc, RESERVED_USERNAME_UNAVAILABLE, "INIT", "c", NULL,
		rc->username);
	  return;
	}
      reply(rc, USERNAME_UNAVAILABLE, "GETL", "c", rc->suggestions);
      return;
    }
  else if (status == MR_DOWN)
    {
      reply(rc, DATABASE_CLOSED, "INIT", "c", NULL);
      return;
    }
  else if (status != MR_SUCCESS)
    {
      reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, error_message(status));
      return;
    }

  rc->username = strdup(login);
  if (!rc->username)
    {
      com_err(whoami, errno, "in LOGN");
      reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, "Out of memory");
      return;
    }
  reply(rc, USERNAME_OK, "GETP", "c", NULL, login);
}

int ctypes[256] = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ^@ - ^O */
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ^P - ^_ */
  1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* SPACE - / */
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, /* 0 - ? */
  2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, /* : - O */
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, /* P - _ */
  2, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, /* ` - o */
  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, /* p - ^? */
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};

void PSWD(reg_client *rc, int argc, char **argv)
{
  long status;
  char *password = argv[0], *p;
  EXEC SQL BEGIN DECLARE SECTION;
  char *login = rc->username;
  EXEC SQL END DECLARE SECTION;

  if (!rc->username || rc->id || argc != 1)
    {
      reply(rc, PROTOCOL_ERROR, "INIT", "c", NULL);
      return;
    }

  /* password quality checking */
  if (strlen(password) < 4)
    {
      reply(rc, PASSWORD_SHORT, "GETP", "c", NULL);
      return;
    }

  if (strlen(password) < 7)
    {
      for (p = password + 1; *p; p++)
	{
	  if (ctypes[*p] != ctypes[*(p - 1)])
	    break;
	}
      if (!*p)
	{
	  reply(rc, PASSWORD_SIMPLE, "GETP", "c", NULL);
	  return;
	}
    }
  
  if (!strcasecmp(password, "GykoR-66") ||
      !strcasecmp(password, "slaRooBey") ||
      !strcasecmp(password, "krang-its") ||
      !strcasecmp(password, "2HotPeetzas") ||
      !strcasecmp(password, "ItzAGurl"))
    {
      reply(rc, PASSWORD_SAMPLE, "GETP", "c", NULL);
      return;
    }

  status = register_kerberos(rc->username, password);
  if (status == MR_IN_USE)
    {
      reply(rc, RESERVED_USERNAME_UNAVAILABLE, "INIT", "c", NULL,
	    rc->username);
      return;
    }
  else if (status)
    {
      com_err(whoami, status, "registering username with Kerberos");
      reply(rc, KADM_ERROR, "INIT", "c", NULL, error_message(status));
      return;
    }
  EXEC SQL UPDATE users SET status = 1 WHERE login = :login;
  EXEC SQL COMMIT;

  reply(rc, DONE, "INIT", "c", NULL, rc->username);
}

void QUIT(reg_client *rc, int argc, char **argv)
{
}

/* Register a user in Moira */
int register_user(int uid, char *username)
{
  char uidbuf[10], *qargv[3], *motd = NULL;
  long status;

  status = mr_connect(hostname);
  if (status)
    return status;

  status = mr_motd(&motd);
  if (status || motd)
    {
      mr_disconnect();
      return MR_DOWN;
    }

  status = krb_get_svc_in_tkt(REG_SVR_PRINCIPAL, REG_SVR_INSTANCE,
			      krb_realmofhost(hostname), MOIRA_SNAME,
			      shorthostname, 1, KEYFILE);
  if (status)
    status += ERROR_TABLE_BASE_krb;
  else
    status = mr_auth("reg_svr");
  if (status)
    {
      com_err(whoami, status, "authenticating to moira");
      mr_disconnect();
      return MR_INTERNAL;
    }

  sprintf(uidbuf, "%d", uid);
  qargv[0] = uidbuf;
  qargv[1] = username;
  qargv[2] = "0";
  status = mr_query("register_user", 3, qargv, NULL, NULL);
  mr_disconnect();
  return status;
}


/* Find some typical available usernames */

char *uname_patterns[] = {
  "FL",		/* johndoe */
  "fmllllll",	/* jmdoe... (last name truncated) */
  "flllllll",   /* jdoe.... ("") */
  "llllllll",	/* doe..... ("") */
  "fml",	/* jmd */
  "Fl",		/* johnd */
  "Lf",		/* doej */
  "Lfm",	/* doejm */
  "F",		/* john */
};
int num_patterns = sizeof(uname_patterns) / sizeof(char *);

char *find_usernames(char *first, char *middle, char *last)
{
  EXEC SQL BEGIN DECLARE SECTION;
  char username[2 * USERS_LOGIN_SIZE];
  int count;
  EXEC SQL END DECLARE SECTION;
  int pat, len;
  char *pp, *up, *fp, *mp, *lp, *unames = NULL;

  fixname(first);
  fixname(middle);
  fixname(last);

  for (pat = 0; pat < num_patterns; pat++)
    {
      up = username;
      fp = first;
      mp = middle;
      lp = last;
      for (pp = uname_patterns[pat]; *pp; pp++)
	{
	  switch (*pp)
	    {
	    case 'f':
	      if (*fp)
		*up++ = *fp++;
	      break;

	    case 'F':
	      if (up - username + strlen(first) < USERS_LOGIN_SIZE)
		up += sprintf(up, "%s", first);
	      else
		goto nextpattern;
	      break;

	    case 'm':
	      if (!*middle)
		goto nextpattern;
	      if (*mp)
		*up++ = *mp++;
	      break;

	    case 'l':
	      if (*lp)
		*up++ = *lp++;
	      break;

	    case 'L':
	      if (up - username + strlen(last) < USERS_LOGIN_SIZE)
		up += sprintf(up, "%s", last);
	      else
		goto nextpattern;
	      break;
	    }
	}
      *up = '\0';

      if (strlen(username) < 3 || strlen(username) >= USERS_LOGIN_SIZE)
	continue;

      EXEC SQL SELECT COUNT(login) INTO :count FROM users
	WHERE login = :username;
      if (sqlca.sqlcode)
	{
	  errno = MR_DBMS_ERR;
	  return NULL;
	}
      if (count == 0)
	{
	  EXEC SQL SELECT COUNT(name) INTO :count FROM list
	    WHERE name = :username;
	  if (sqlca.sqlcode)
	    {
	      errno = MR_DBMS_ERR;
	      return NULL;
	    }
	}
      if (count == 0)
	{
	  EXEC SQL SELECT COUNT(label) INTO :count FROM filesys
	    WHERE label = :username;
	  if (sqlca.sqlcode)
	    {
	      errno = MR_DBMS_ERR;
	      return NULL;
	    }
	}

      if (count == 0)
	{
	  if (unames)
	    {
	      unames = realloc(unames, strlen(unames) + strlen(username) + 3);
	      if (!unames)
		return NULL;
	      strcat(unames, ", ");
	      strcat(unames, username);
	    }
	  else
	    {
	      unames = strdup(username);
	      if (!unames)
		return NULL;
	    }
	}

    nextpattern:
      ;
    }

  /* unames will be NULL if we couldn't suggest a username. Clear
     errno so the caller can distinguish this from an error case. */
  errno = 0;
  return unames;
}

void fixname(char *name)
{
  char *s, *d;

  for (s = d = name; *s; s++)
    {
      if (isalnum(*s))
	*d++ = tolower(*s);
    }
  *d = '\0';
}

void *xmalloc(size_t bytes)
{
  void *buf = malloc(bytes);

  if (buf)
    return buf;

  com_err(whoami, errno, "in xmalloc");
  exit(1);
}

void *xrealloc(void *ptr, size_t bytes)
{
  void *buf = realloc(ptr, bytes);

  if (buf)
    return buf;

  com_err(whoami, errno, "in xrealloc");
  exit(1);
}

char *xstrdup(char *str)
{
  char *buf = strdup(str);

  if (buf)
    return buf;

  com_err(whoami, errno, "in xstrdup");
  exit(1);
}

void mr_com_err(const char *whoami, long code, const char *fmt, va_list pvar)
{
  if (whoami)
    {
      fputs(whoami, stderr);
      if (cl)
	fprintf(stderr, "[#%d]", cl->clientid);
      fputs(": ", stderr);
    }
  if (code) {
    fputs(error_message(code), stderr);
    fputs(" ", stderr);
  }
  if (fmt)
    vfprintf(stderr, fmt, pvar);
  putc('\n', stderr);
}

void sigshut(int sig)
{
  state = RS_EXITING;
}
Commit	Line	Data
b50f996d	1	/* $Id$
	2	*
	3	* Server for user registration with Moira and Kerberos.
	4	*
	5	* Copyright (C) 1987-1998 by the Massachusetts Institute of Technology
	6	* For copying and distribution information, please see the file
	7	* <mit-copyright.h>.
	8	*/
	9
	10	#include <mit-copyright.h>
	11	#include <moira.h>
	12	#include <mr_private.h>
	13	#include <moira_schema.h>
	14	#include <moira_site.h>
	15	#include "reg_svr.h"
	16
	17	#include <sys/types.h>
	18	#include <sys/socket.h>
	19	#include <sys/stat.h>
	20	#include <sys/time.h>
	21	#include <sys/utsname.h>
	22
	23	#include <netinet/in.h>
	24	#include <netdb.h>
	25
	26	#include <ctype.h>
	27	#include <errno.h>
	28	#include <signal.h>
	29	#include <stdarg.h>
	30	#include <stdio.h>
	31	#include <stdlib.h>
	32	#include <string.h>
	33	#include <unistd.h>
	34
	35	#include <com_err.h>
	36	#include <krb.h>
	37
	38	EXEC SQL INCLUDE sqlca;
	39
	40	RCSID("$Header$");
	41
	42	char whoami, hostname, *shorthostname;
	43
	44	char find_usernames(char first, char middle, char last);
	45	void fixname(char *name);
	46	int register_user(int uid, char *username);
	47	void mr_com_err(const char whoami, long code, const char fmt, va_list pvar);
	48	void sigshut(int);
	49
	50	reg_client *cl = NULL;
	51	enum { RS_RUNNING, RS_SLEEPING, RS_EXITING } state = RS_RUNNING;
	52
	53	int main(int argc, char **argv)
	54	{
	55	int listener, nfds, i, clientid = 0;
	56	fd_set readfds, xreadfds;
	57	reg_client *clients;
	58	int nclients, clientssize;
	59	long status;
	60	char *db = "moira";
	61	struct utsname uts;
	62	struct hostent *h;
	63	struct sigaction sa;
	64	struct stat st;
65
66	whoami = strrchr(argv[0], '/');
67	whoami = whoami ? whoami + 1 : argv[0];
68
69	set_com_err_hook(mr_com_err);
70
71	/* Read keys */
72	if (!read_rsa_key())
73	{
74	com_err(whoami, errno, "reading RSA key");
75	exit(1);
76	}
77	if (!read_hmac_key())
78	{
79	com_err(whoami, errno, "reading HMAC key");
80	exit(1);
81	}
82
83	/* Read error messages */
84	if (!read_errors())
85	{
86	com_err(whoami, errno, "reading error messages");
87	exit(1);
88	}
89
90	/* Connect to database */
91	EXEC SQL CONNECT :db IDENTIFIED BY :db;
92	if (sqlca.sqlcode)
93	{
94	char err_msg[256];
95	int bufsize = 256, msglength = 0;
96
97	sqlglm(err_msg, &bufsize, &msglength);
98	err_msg[msglength] = 0;
99	com_err(whoami, 0, "SQL error connecting to DBMS:\n%s", err_msg);
100	exit(1);
101	}
102
103	/* Get my hostname */
104	uname(&uts);
105	h = gethostbyname(uts.nodename);
106	if (!h)
107	{
108	com_err(whoami, 0, "Couldn't resolve hostname %s", uts.nodename);
109	exit(1);
110	}
111	hostname = lowercase(xstrdup(h->h_name));
112	shorthostname = xstrdup(hostname);
113	if (strchr(shorthostname, '.'))
114	*strchr(shorthostname, '.') = '\0';
115
116	/* Initialize kerberos */
117	status = init_kerberos();
118	if (status)
119	{
120	com_err(whoami, status, "initializing kerberos library");
121	exit(1);
122	}
123
124	/* Set up listening socket. */
125	listener = mr_listen("moira_ureg");
126	if (listener < 0)
127	{
128	com_err(whoami, errno, "couldn't create listening socket");
129	exit(1);
130	}
131	FD_ZERO(&xreadfds);
132	FD_SET(listener, &xreadfds);
133	nfds = listener + 1;
134
135	/* Initialize client array. */
136	nclients = 0;
137	clientssize = 5;
138	clients = malloc(clientssize * sizeof(reg_client));
139	if (!clients)
140	{
141	com_err(whoami, errno, "creating client array");
142	exit(1);
143	}
144
145	/* Set up signal handlers */
146	sa.sa_flags = 0;
147	sigemptyset(&sa.sa_mask);
148	sa.sa_handler = sigshut;
149	sigaction(SIGTERM, &sa, NULL);
150	sigaction(SIGINT, &sa, NULL);
151	sigaction(SIGHUP, &sa, NULL);
152	sa.sa_handler = SIG_IGN;
153	sigaction(SIGPIPE, &sa, NULL);
154
155	com_err(whoami, 0, "started (pid %d)", getpid());
156	com_err(whoami, 0, rcsid);
157
158	/* Main loop */
159	while (state != RS_EXITING)
160	{
161	if (state == RS_RUNNING && stat(MOIRA_MOTD_FILE, &st) == 0)
162	{
163	state == RS_SLEEPING;
164	com_err(whoami, 0, "found motd. reg_svr is sleeping");
165	}
166	else if (state == RS_SLEEPING && stat(MOIRA_MOTD_FILE, &st) == -1)
167	{
168	state == RS_RUNNING;
169	com_err(whoami, 0, "motd gone. reg_svr is running");
170	}
171
172	memcpy(&readfds, &xreadfds, sizeof(readfds));
173	if (select(nfds, &readfds, NULL, NULL, NULL) == -1)
174	{
175	if (errno != EINTR)
176	com_err(whoami, errno, "in select");
177	continue;
178	}
179
180	if (FD_ISSET(listener, &readfds))
181	{
182	int newconn, addrlen = sizeof(struct sockaddr_in);
183	struct sockaddr_in addr;
184
185	newconn = accept(listener, (struct sockaddr *)&addr, &addrlen);
186	if (newconn < 0)
187	com_err(whoami, errno, "accepting new connection");
188	else
189	{
190	nclients++;
191	if (nclients > clientssize)
192	{
193	clientssize = 2 * clientssize;
194	clients = xrealloc(clients, clientssize *
195	sizeof(reg_client));
196	}
197
198	cl = &clients[nclients - 1];
199	memset(cl, 0, sizeof(reg_client));
200	cl->fd = newconn;
201	cl->lastmod = time(NULL);
202	cl->clientid = ++clientid;
203	cl->random = init_rand(cl);
204	FD_SET(newconn, &xreadfds);
205	if (newconn >= nfds)
206	nfds = newconn + 1;
207
208	com_err(whoami, 0,
209	"New connection from %s port %d (now %d client%s)",
210	inet_ntoa(addr.sin_addr), (int)ntohs(addr.sin_port),
211	nclients, nclients != 1 ? "s" : "");
212	}
213	}
214
215	for (i = 0; i < nclients; i++)
216	{
217	cl = &clients[i];
218	if (FD_ISSET(cl->fd, &readfds))
219	{
220	cl->lastmod = time(NULL);
221	if (!cl->buf)
222	{
223	/* We're just starting */
224	cl->buf = malloc(3);
225	if (!cl->buf)
226	{
227	com_err(whoami, errno, "allocating read buffer");
228	reply(cl, INTERNAL_ERROR, "INIT", "c", NULL,
229	"Out of memory");
230	goto reap;
231	}
232	cl->nread = 0;
233	}
234
235	if (cl->nread < 3)
236	{
237	/* We haven't read the length byte yet... */
238	cl->nread += read(cl->fd, cl->buf + cl->nread,
239	3 - cl->nread);
240	if (cl->nread == 3)
241	{
242	cl->nmax = cl->buf[1] * 256 + cl->buf[2] + 3;
243	cl->buf = realloc(cl->buf, cl->nmax + 3);
244	if (!cl->buf)
245	{
246	com_err(whoami, errno, "reallocating read buffer");
247	reply(cl, INTERNAL_ERROR, "INIT", "c", NULL,
248	"Out of memory");
249	goto reap;
250	}
251	}
252	else if (cl->nread == 0)
253	{
254	/* client has closed connection. setting
255	lastmod will cause it to be reaped */
256	cl->lastmod = 0;
257	}
258	}
259	else
260	{
261	/* We know how long the packet is supposed to be */
262	cl->nread += read(cl->fd, cl->buf + cl->nread,
263	cl->nmax - cl->nread);
264	if (cl->nread == cl->nmax)
265	{
266	parse_packet(cl, cl->buf[0], cl->nread - 3, cl->buf + 3,
267	state == RS_SLEEPING);
268	free(cl->buf);
269	cl->buf = NULL;
270	}
271	}
272	}
273
274	reap:
275	if (cl->lastmod < time(NULL) - TIMEOUT)
276	{
277	com_err(whoami, 0, "Closed connection. (now %d client%s)",
278	nclients - 1, nclients != 2 ? "s" : "");
279	shutdown(cl->fd, 2);
280	close(cl->fd);
281	FD_CLR(cl->fd, &xreadfds);
282	free(cl->buf);
283	free(cl->id);
284	free(cl->username);
285	free(cl->suggestions);
286	free(cl->random);
287	clients[i] = clients[--nclients];
288	i--;
289	}
290	}
291	cl = NULL;
292	}
293	com_err(whoami, 0, "Exiting.");
294	}
295
296	void RIFO(reg_client rc, int argc, char *argv)
297	{
298	EXEC SQL BEGIN DECLARE SECTION;
299	char ufirst, umiddle, ulast, id;
300	char login[USERS_LOGIN_SIZE], first[USERS_FIRST_SIZE];
301	char middle[USERS_MIDDLE_SIZE], last[USERS_LAST_SIZE];
302	char fullname[USERS_FIRST_SIZE + USERS_MIDDLE_SIZE + USERS_LAST_SIZE];
303	char class[USERS_TYPE_SIZE];
304	int uid, status, secure, sqlstatus;
305	EXEC SQL END DECLARE SECTION;
306
307	if (rc->uid \|\| argc != 4)
308	{
309	reply(rc, PROTOCOL_ERROR, "INIT", "c", NULL);
310	return;
311	}
312
313	ufirst = argv[0];
314	umiddle = argv[1];
315	ulast = argv[2];
316	id = argv[3];
317
318	/* "ORDER BY status" so that if there's both a matching state 0 entry
319	and a matching state 3 entry, we'll get the former. */
320	EXEC SQL DECLARE csr_id CURSOR FOR
321	SELECT login, unix_uid, status, secure, first, middle, last, type
322	FROM users WHERE clearid = :id ORDER BY status;
323	EXEC SQL OPEN csr_id;
324	while (1)
325	{
326	EXEC SQL FETCH csr_id INTO :login, :uid, :status,
327	:secure, :first, :middle, :last, :class;
328	if (sqlca.sqlcode)
329	break;
330	strtrim(login);
331	strtrim(first);
332	strtrim(middle);
333	strtrim(last);
334	strtrim(class);
335
336	/* Check names, allowing for the possibility that Moira and the
337	user might have them split up differently. eg, Mary/Ann/Singleton
338	vs. Mary Ann/Singleton. */
339	if (strcasecmp(last, ulast) && strncasecmp(last, ulast, strlen(last)) &&
340	strncasecmp(last, ulast, strlen(ulast)))
341	continue;
342	if (strlen(last) > 3 && strlen(ulast) < 3)
343	continue;
344	if (strcasecmp(first, ufirst) &&
345	strncasecmp(first, ufirst, strlen(first)) &&
346	strncasecmp(first, ufirst, strlen(ufirst)))
347	continue;
348	if (strlen(first) > 3 && strlen(ufirst) < 3)
349	continue;
350	/* Ignore the middle name since Moira doesn't have those reliably */
351	break;
352	}
353	sqlstatus = sqlca.sqlcode;
354	EXEC SQL CLOSE csr_id;
355
356	if (sqlstatus)
357	{
358	reply(rc, NOT_FOUND_IN_DATABASE, "GETN", "d", NULL);
359	return;
360	}
361
362	switch (status)
363	{
364	case US_REGISTERED:
365	case US_ENROLLED:
366	case US_ENROLL_NOT_ALLOWED:
367	reply(rc, ALREADY_REGISTERED, "INIT", "c", NULL, login);
368	return;
369
370	case US_DELETED:
371	reply(rc, ACCOUNT_DELETED, "INIT", "c", NULL, login);
372	return;
373
374	case US_NOT_ALLOWED:
375	reply(rc, NOT_ELIGIBLE, "INIT", "c", NULL);
376	return;
377
378	default:
379	break;
380	}
381
382	rc->uid = uid;
383	sprintf(fullname, "%s %s%s%s", first, middle, *middle ? " " : "", last);
384	if (!strcmp(class, "MITS"))
385	strcpy(class, "STAFF");
386	if (secure == 1)
387	{
388	rc->id = strdup(id);
389	if (!rc->id)
390	{
391	com_err(whoami, errno, "in RIFO");
392	reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, "Out of memory");
393	return;
394	}
395	}
396	if (*login != '#')
397	{
398	rc->reserved_username = 1;
399	rc->username = strdup(login);
400	if (!rc->username)
401	{
402	com_err(whoami, errno, "in RIFO");
403	reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, "Out of memory");
404	return;
405	}
406	}
407	else
408	{
409	rc->suggestions = find_usernames(first, middle, last);
8dc13a24	410	if (!rc->suggestions && errno)
b50f996d	411	{
b50f996d	412	com_err(whoami, errno, "in RIFO");
8dc13a24	413	reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, error_message(errno));
b50f996d	414	return;
	415	}
	416	}
	417
	418	if (rc->id)
	419	reply(rc, FOUND, "GETW", "c", NULL, fullname, class);
	420	else if (!rc->username)
	421	reply(rc, FOUND, "GETL", "c", rc->suggestions, fullname, class);
	422	else
84005ecc	423	reply(rc, FORCED_USERNAME, "GETP", "c", NULL, rc->username);
b50f996d	424	}
	425
	426	void SWRD(reg_client rc, int argc, char *argv)
	427	{
	428	char *words[6];
	429	int i;
	430
	431	if (!rc->id \|\| argc != 6)
	432	{
	433	reply(rc, PROTOCOL_ERROR, "INIT", "c", NULL);
	434	return;
	435	}
	436
	437	getwordlist(rc->id, words);
	438	for (i = 0; i < 6; i++)
	439	{
	440	if (strcasecmp(strtrim(argv[i]), words[i]))
	441	break;
	442	}
	443	if (i != 6)
	444	{
	445	reply(rc, BAD_SIX_WORDS, "GETW", "d", NULL);
	446	return;
	447	}
	448
	449	free(rc->id);
	450	rc->id = NULL;
	451	if (!rc->username)
	452	reply(rc, NO_MESSAGE, "GETL", "c", rc->suggestions);
	453	else
	454	reply(rc, FORCED_USERNAME, "GETP", "c", NULL, rc->username);
	455	}
	456
	457	void LOGN(reg_client rc, int argc, char *argv)
	458	{
	459	int i;
	460	char *login;
	461	long status;
	462
	463	if (!rc->uid \|\| rc->id \|\| rc->username \|\| argc != 1)
	464	{
	465	reply(rc, PROTOCOL_ERROR, "INIT", "c", NULL);
	466	return;
	467	}
	468
	469	login = argv[0];
	470
	471	/* make sure someone's not trying to overrun reply */
	472	if (strlen(login) > 100)
	473	{
	474	com_err(whoami, 0, "Buffer overrun attempted? Closing connection");
	475	rc->lastmod = 0;
	476	return;
	477	}
	478
	479	if ((strlen(login) < 3) \|\| (strlen(login) > USERS_LOGIN_SIZE - 1) \|\|
	480	(login[0] == '_') \|\| isdigit(login[0]))
	481	{
	482	reply(rc, BAD_USERNAME, "GETL", "c", rc->suggestions, login,
	483	3, USERS_LOGIN_SIZE - 1);
	484	return;
	485	}
	486
	487	for (i = 0; i < strlen(login); i++)
488	{
489	if (!islower(login[i]) && !isdigit(login[i]) && (login[i] != '_'))
490	{
491	reply(rc, BAD_USERNAME, "GETL", "c", rc->suggestions, login,
492	3, USERS_LOGIN_SIZE - 1);
493	return;
494	}
495	}
496
497	status = check_kerberos(login);
498	if (status == MR_SUCCESS)
499	status = register_user(rc->uid, login);
500
501	if (status == MR_IN_USE)
502	{
503	if (rc->reserved_username)
504	{
505	reply(rc, RESERVED_USERNAME_UNAVAILABLE, "INIT", "c", NULL,
506	rc->username);
507	return;
508	}
509	reply(rc, USERNAME_UNAVAILABLE, "GETL", "c", rc->suggestions);
510	return;
511	}
512	else if (status == MR_DOWN)
513	{
514	reply(rc, DATABASE_CLOSED, "INIT", "c", NULL);
515	return;
516	}
517	else if (status != MR_SUCCESS)
518	{
519	reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, error_message(status));
520	return;
521	}
522
523	rc->username = strdup(login);
524	if (!rc->username)
525	{
526	com_err(whoami, errno, "in LOGN");
527	reply(rc, INTERNAL_ERROR, "INIT", "c", NULL, "Out of memory");
528	return;
529	}
530	reply(rc, USERNAME_OK, "GETP", "c", NULL, login);
531	}
532
533	int ctypes[256] = {
534	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ^@ - ^O */
535	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* ^P - ^_ */
536	1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, /* SPACE - / */
537	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, /* 0 - ? */
538	2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, /* : - O */
539	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, /* P - _ */
540	2, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, /* ` - o */
541	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, /* p - ^? */
542	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
543	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
544	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
545	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
546	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
547	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
548	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
549	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
550	};
551
552	void PSWD(reg_client rc, int argc, char *argv)
553	{
554	long status;
555	char password = argv[0], p;
556	EXEC SQL BEGIN DECLARE SECTION;
557	char *login = rc->username;
558	EXEC SQL END DECLARE SECTION;
559
560	if (!rc->username \|\| rc->id \|\| argc != 1)
561	{
562	reply(rc, PROTOCOL_ERROR, "INIT", "c", NULL);
563	return;
564	}
565
566	/* password quality checking */
567	if (strlen(password) < 4)
568	{
569	reply(rc, PASSWORD_SHORT, "GETP", "c", NULL);
570	return;
571	}
572
573	if (strlen(password) < 7)
574	{
575	for (p = password + 1; *p; p++)
576	{
577	if (ctypes[p] != ctypes[(p - 1)])
578	break;
579	}
580	if (!*p)
581	{
582	reply(rc, PASSWORD_SIMPLE, "GETP", "c", NULL);
583	return;
584	}
585	}
586
587	if (!strcasecmp(password, "GykoR-66") \|\|
588	!strcasecmp(password, "slaRooBey") \|\|
589	!strcasecmp(password, "krang-its") \|\|
590	!strcasecmp(password, "2HotPeetzas") \|\|
591	!strcasecmp(password, "ItzAGurl"))
592	{
593	reply(rc, PASSWORD_SAMPLE, "GETP", "c", NULL);
594	return;
595	}
596
597	status = register_kerberos(rc->username, password);
598	if (status == MR_IN_USE)
599	{
600	reply(rc, RESERVED_USERNAME_UNAVAILABLE, "INIT", "c", NULL,
601	rc->username);
602	return;
603	}
604	else if (status)
605	{
606	com_err(whoami, status, "registering username with Kerberos");
607	reply(rc, KADM_ERROR, "INIT", "c", NULL, error_message(status));
608	return;
609	}
610	EXEC SQL UPDATE users SET status = 1 WHERE login = :login;
611	EXEC SQL COMMIT;
612
613	reply(rc, DONE, "INIT", "c", NULL, rc->username);
614	}
615
616	void QUIT(reg_client rc, int argc, char *argv)
617	{
618	}
619
620	/* Register a user in Moira */
621	int register_user(int uid, char *username)
622	{
623	char uidbuf[10], qargv[3], motd = NULL;
624	long status;
625
626	status = mr_connect(hostname);
627	if (status)
628	return status;
629
630	status = mr_motd(&motd);
631	if (status \|\| motd)
632	{
633	mr_disconnect();
634	return MR_DOWN;
635	}
636
637	status = krb_get_svc_in_tkt(REG_SVR_PRINCIPAL, REG_SVR_INSTANCE,
638	krb_realmofhost(hostname), MOIRA_SNAME,
639	shorthostname, 1, KEYFILE);
640	if (status)
641	status += ERROR_TABLE_BASE_krb;
642	else
643	status = mr_auth("reg_svr");
644	if (status)
645	{
646	com_err(whoami, status, "authenticating to moira");
647	mr_disconnect();
648	return MR_INTERNAL;
649	}
650
651	sprintf(uidbuf, "%d", uid);
652	qargv[0] = uidbuf;
653	qargv[1] = username;
654	qargv[2] = "0";
655	status = mr_query("register_user", 3, qargv, NULL, NULL);
656	mr_disconnect();
657	return status;
658	}
659
660
661	/* Find some typical available usernames */
662
663	char *uname_patterns[] = {
664	"FL", /* johndoe */
665	"fmllllll", /* jmdoe... (last name truncated) */
666	"flllllll", /* jdoe.... ("") */
667	"llllllll", /* doe..... ("") */
668	"fml", /* jmd */
669	"Fl", /* johnd */
670	"Lf", /* doej */
671	"Lfm", /* doejm */
672	"F", /* john */
673	};
674	int num_patterns = sizeof(uname_patterns) / sizeof(char *);
675
676	char find_usernames(char first, char middle, char last)
677	{
678	EXEC SQL BEGIN DECLARE SECTION;
679	char username[2 * USERS_LOGIN_SIZE];
680	int count;
681	EXEC SQL END DECLARE SECTION;
682	int pat, len;
683	char pp, up, fp, mp, lp, unames = NULL;
684
685	fixname(first);
686	fixname(middle);
687	fixname(last);
688
689	for (pat = 0; pat < num_patterns; pat++)
690	{
691	up = username;
692	fp = first;
693	mp = middle;
694	lp = last;
695	for (pp = uname_patterns[pat]; *pp; pp++)
696	{
697	switch (*pp)
698	{
699	case 'f':
700	if (*fp)
701	up++ = fp++;
702	break;
703
704	case 'F':
705	if (up - username + strlen(first) < USERS_LOGIN_SIZE)
706	up += sprintf(up, "%s", first);
707	else
708	goto nextpattern;
709	break;
710
711	case 'm':
712	if (!*middle)
713	goto nextpattern;
714	if (*mp)
715	up++ = mp++;
716	break;
717
718	case 'l':
719	if (*lp)
720	up++ = lp++;
721	break;
722
723	case 'L':
724	if (up - username + strlen(last) < USERS_LOGIN_SIZE)
725	up += sprintf(up, "%s", last);
726	else
727	goto nextpattern;
728	break;
729	}
730	}
731	*up = '\0';
732
d1d04a6c	733	if (strlen(username) < 3 \|\| strlen(username) >= USERS_LOGIN_SIZE)
b50f996d	734	continue;
	735
	736	EXEC SQL SELECT COUNT(login) INTO :count FROM users
	737	WHERE login = :username;
	738	if (sqlca.sqlcode)
8dc13a24	739	{
	740	errno = MR_DBMS_ERR;
	741	return NULL;
	742	}
b50f996d	743	if (count == 0)
	744	{
	745	EXEC SQL SELECT COUNT(name) INTO :count FROM list
	746	WHERE name = :username;
	747	if (sqlca.sqlcode)
8dc13a24	748	{
	749	errno = MR_DBMS_ERR;
	750	return NULL;
	751	}
b50f996d	752	}
	753	if (count == 0)
	754	{
	755	EXEC SQL SELECT COUNT(label) INTO :count FROM filesys
	756	WHERE label = :username;
	757	if (sqlca.sqlcode)
8dc13a24	758	{
	759	errno = MR_DBMS_ERR;
	760	return NULL;
	761	}
b50f996d	762	}
	763
	764	if (count == 0)
	765	{
	766	if (unames)
	767	{
	768	unames = realloc(unames, strlen(unames) + strlen(username) + 3);
	769	if (!unames)
	770	return NULL;
	771	strcat(unames, ", ");
	772	strcat(unames, username);
	773	}
	774	else
	775	{
	776	unames = strdup(username);
	777	if (!unames)
	778	return NULL;
	779	}
	780	}
	781
	782	nextpattern:
	783	;
	784	}
	785
8dc13a24	786	/* unames will be NULL if we couldn't suggest a username. Clear
	787	errno so the caller can distinguish this from an error case. */
	788	errno = 0;
b50f996d	789	return unames;
	790	}
	791
	792	void fixname(char *name)
	793	{
	794	char s, d;
	795
	796	for (s = d = name; *s; s++)
	797	{
	798	if (isalnum(*s))
	799	d++ = tolower(s);
	800	}
	801	*d = '\0';
	802	}
	803
	804	void *xmalloc(size_t bytes)
	805	{
	806	void *buf = malloc(bytes);
	807
	808	if (buf)
	809	return buf;
	810
	811	com_err(whoami, errno, "in xmalloc");
	812	exit(1);
	813	}
	814
	815	void xrealloc(void ptr, size_t bytes)
	816	{
	817	void *buf = realloc(ptr, bytes);
	818
	819	if (buf)
	820	return buf;
	821
	822	com_err(whoami, errno, "in xrealloc");
	823	exit(1);
	824	}
	825
	826	char xstrdup(char str)
	827	{
	828	char *buf = strdup(str);
	829
	830	if (buf)
	831	return buf;
	832
	833	com_err(whoami, errno, "in xstrdup");
	834	exit(1);
	835	}
	836
	837	void mr_com_err(const char whoami, long code, const char fmt, va_list pvar)
	838	{
	839	if (whoami)
	840	{
	841	fputs(whoami, stderr);
	842	if (cl)
	843	fprintf(stderr, "[#%d]", cl->clientid);
	844	fputs(": ", stderr);
	845	}
	846	if (code) {
	847	fputs(error_message(code), stderr);
	848	fputs(" ", stderr);
	849	}
	850	if (fmt)
	851	vfprintf(stderr, fmt, pvar);
	852	putc('\n', stderr);
853	}
854
855	void sigshut(int sig)
856	{
857	state = RS_EXITING;
858	}