Refactoring - move most functions into functions.h/functions.c except connect/exit functions only relevant in main.c.

1 files changed, 557 insertions, 0 deletions

diff --git a/functions.c b/functions.c
index b9983d7..0aefa05 100644
--- a/functions.c
+++ b/functions.c
@@ -355,3 +355,560 @@ void updategreetings(char *greeting001, char *greeting002, char *greeting003, ch
     updategreetingnick(greeting005c, "005", newnickcpy, oldnick);
   }
 }
+
+// Return index of requested client FD within the clients array.
+// TODO - Use this wherever we are calculating the position (various places) instead of
+// duplicating code.
+int arrindex(struct client *clients, int clientfd) {
+  // Find the client in the clients array and make sure they are authenticated
+  for (int i = 0; i < MAXCLIENTS; i++) {
+    if (clients[i].fd == clientfd) {
+      return i;
+    }
+  }
+
+  // Something went wrong, we didn't find it
+  return 0;
+}
+
+// Send whatever string to a specific client by providing the FD
+// If "bypass" == 1 then permit sending to client even if unauthenticated (for instance for a CAP LS response)
+int sendtoclient(int fd, char *strsrc, struct client *clients, struct settings *settings, int bypass) {
+  // Copy to new string for passing to appendcrlf() to avoid overrun in appendcrlf()
+  char str[MAXDATASIZE];
+  strcpy(str, strsrc);
+
+  appendcrlf(str); // Do this just before sending so callers don't need to worry about it
+
+  int i = 0;
+  // Find the client in the clients array and make sure they are authenticated
+  for (i = 0; i < MAXCLIENTS; i++) {
+    if (clients[i].fd == fd) {
+      // Found client in array, check authentication status
+      if (!clients[i].authed && !bypass) {
+        debugprint(DEBUG_SOME, "sendtoclient(): skipping unauthenticated client with fd %d.\n", clients[i].fd);
+        return 0;
+      }
+      // Break when we get to the correct fd, "i" is now the position in the clients array of our client
+      break;
+    }
+  }
+
+  debugprint(DEBUG_SOME, "sendtoclient(): sending \"%s\" (length %zd) to client with fd %d.\n", str, strlen(str), fd);
+  if (socksend(clients[i].ssl, str, strlen(str), settings->clienttls) == -1) {
+    perror("error: sendtoclient() socksend()\n");
+    debugprint(DEBUG_CRIT, "error: sendtoclient() socksend() error sending to client with fd '%d', errno '%d'.\n", fd, errno);
+    return 0;
+  }
+
+  return 1;
+}
+
+// Relay/send message to all clients (optionally except one)
+// "except" is used to send to all clients _except_ the fd provided (except = 0 (EXCEPT_NONE) avoids this, i.e. sends to all)
+// "except" is really the "sourcefd" and is also used as part of the authentication check - this is messy and they should perhaps be two separate arguments.
+int sendtoallclients(struct client *clients, char *strsrc, int except, struct settings *settings) {
+
+  char *sendertype;
+
+  // Copy to new string for passing to appendcrlf() to avoid overrun in appendcrlf()
+  char str[MAXDATASIZE];
+  strcpy(str, strsrc);
+
+  appendcrlf(str); // Do this just before sending so callers don't need to worry about it
+
+  // Decide what sort of text to prefix the debug output with
+  // At the moment if non-zero "except" is specified then it must be a message from a bouncer client
+  // and if "except" is zero then it must be a message from the real IRC server
+  if (except) {
+    sendertype = "bouncer-client";
+  } else {
+    sendertype = "bouncer-server";
+  }
+
+  // Find the sending client in the clients array and make sure they are authenticated
+  for (int i = 0; i < MAXCLIENTS; i++) {
+    // Trust clientfd of 0, only we can set that ourselves
+    if (!except) {
+      debugprint(DEBUG_FULL, "sendtoallclients(): trusting clientfd of 0.\n");
+      break;
+    }
+    if (clients[i].fd == except) {
+      // Found client in array, check authentication status
+      if (!clients[i].authed) {
+        debugprint(DEBUG_SOME, "sendtoallclients(): skipping unauthenticated client with fd %d.\n", clients[i].fd);
+        return 0;
+      }
+    }
+  }
+
+  // Relay/send to all clients...
+  for (int i = 0; i < MAXCLIENTS; i++) {
+    // Skip the current client if "except" non-zero (no need to send back to itself)
+    if (clients[i].fd == except) {
+      continue;
+    }
+    // ...but only if they are connected...
+    if (clients[i].fd > 0) {
+      // ...and authenticated
+      if (!clients[i].authed) {
+        debugprint(DEBUG_SOME, "sendtoallclients(): skipping unauthenticated client with fd %d.\n", clients[i].fd);
+        continue;
+      }
+      debugprint(DEBUG_SOME, "sendtoallclients(): %s: sending '%s' to client with fd %d.\n", sendertype, str, clients[i].fd);
+      if (socksend(clients[i].ssl, str, strlen(str), settings->clienttls) == -1) {
+        perror("error: sendtoallclients() socksend()\n");
+        debugprint(DEBUG_CRIT, "error: sendtoallclients() socksend() error sending to client with fd '%d', errno '%d'.\n", clients[i].fd, errno);
+      }
+    }
+  }
+
+  return 1;
+}
+
+// Send whatever string to the real IRC server
+// Client FD and arrays needed to make sure anything relayed from a client is from an authenticated client.
+// clientfd of "0" means trusted, used when we are sending things ourselves that weren't relayed
+// from a real client.
+int sendtoserver(SSL *server_ssl, char *strsrc, int str_len, int clientfd, struct client *clients, struct settings *settings) {
+  // Copy to new string for passing to appendcrlf() to avoid overrun in appendcrlf()
+  char str[MAXDATASIZE];
+  strcpy(str, strsrc);
+
+  appendcrlf(str); // Do this just before sending so callers don't need to worry about it
+  str_len = strlen(str); // Recalculate str_len in case it changed (TODO: so do we even need to pass it to this function?)
+
+  // Find the sending client in the clients array and make sure they are authenticated
+  for (int i = 0; i < MAXCLIENTS; i++) {
+    // Trust clientfd of 0, only we can set that ourselves
+    if (!clientfd) {
+      debugprint(DEBUG_FULL, "sendtoserver(): trusting clientfd of 0.\n");
+      break;
+    }
+    if (clients[i].fd == clientfd) {
+      // Found client in array, check authentication status
+      if (!clients[i].authed) {
+        debugprint(DEBUG_SOME, "sendtoserver(): skipping unauthenticated client with fd %d.\n", clients[i].fd);
+        return 0;
+      }
+    }
+  }
+
+  debugprint(DEBUG_SOME, "sendtoserver(): sending '%s' to IRC server (length %d).\n", str, str_len);
+  if (socksend(server_ssl, str, str_len, settings->servertls) == -1) {
+    printf("error: sendtoserver() socksend()\n");
+    debugprint(DEBUG_CRIT, "error: sendtoserver() socksend() error sending to server, errno '%d'.\n", clientfd, errno);
+    return 0;
+  }
+
+  return 1;
+}
+
+// Disconnect the client fd "fd" by close()ing it and remove
+// it from the array of clients.
+// Also set its authentication and registration statuses to 0.
+// Also set the pending statuses to 0
+int disconnectclient(int fd, struct client *clients, struct ircdstrings *ircdstrings, struct settings *settings) {
+  debugprint(DEBUG_SOME, "disconnectclient(): disconnecting client fd '%d'\n", fd);
+
+  // Alert other clients about the disconnection (don't send yet, we haven't removed from the clients array yet)
+  char alertmsg[MAXDATASIZE];
+  if (!snprintf(alertmsg, MAXDATASIZE, "NOTICE %s :blabouncer: client with fd %d has disconnected.", ircdstrings->ircnick, fd)) {
+    fprintf(stderr, "Error while preparing authentication failure NOTICE!\n");
+    debugprint(DEBUG_CRIT, "Error while preparing authentication failure NOTICE!\n");
+    alertmsg[0] = '\0';
+  }
+  // Remove the client from the clients array
+  for (int i = 0; i < MAXCLIENTS; i++) {
+    if (clients[i].fd == fd) {
+      debugprint(DEBUG_FULL, "found and clearing fd %d from clients[%d]\n", fd, i);
+      clients[i].fd = 0;
+      clients[i].authed = 0;
+      clients[i].registered = 0;
+      clients[i].pendingchannelmode = 0;
+      clients[i].pendingban = 0;
+      clients[i].pendingwho = 0;
+      clients[i].pendinglist = 0;
+      clients[i].pendingwhois = 0;
+      clients[i].pendingwhowas = 0;
+      clients[i].pendingnames = 0;
+      clients[i].pendingcap = 0;
+      if (settings->clienttls) {
+        // Finish up with OpenSSL if using client TLS
+        SSL_free(clients[i].ssl);
+      }
+      // Close the socket
+      close(fd);
+      // Now clients array is cleared, inform all other clients (source "0" since we trust this message)
+      sendtoallclients(clients, alertmsg, 0, settings);
+      return 1;
+    }
+  }
+
+  // If we got here, we didn't find and clear the client
+  // TODO - Do something with a failed return code
+  return 0;
+}
+
+int createchannel(struct channel *channels, char *name, char *topic, char *topicwho, char *topicwhen) {
+  debugprint(DEBUG_FULL, "createchannel(): given '%s', '%s', '%s', and '%s'.\n", name, topic, topicwho, topicwhen);
+
+  // Make sure the channel doesn't already exist
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (strncmp(channels[i].name, name, strlen(name)) == 0) {
+      perror("error: createchannel(): channel name already exists.\n");
+      return 0;
+      break;
+    }
+  }
+
+  // Find a free slot in the array (when the channel name is not set (0th character is '\0'))...
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (!channels[i].name[0]) {
+      // ...and set the name and topic
+      strncpy(channels[i].name, name, strlen(name));
+      channels[i].name[strlen(name)] = '\0';
+      debugprint(DEBUG_FULL, "createchannel(): name given was '%s', length '%ld'.\n", name, strlen(name));
+      debugprint(DEBUG_FULL, "createchannel(): name set to '%s', length '%ld'.\n", channels[i].name, strlen(channels[i].name));
+      strncpy(channels[i].topic, topic, strlen(topic));
+      channels[i].topic[strlen(topic)] = '\0';
+      debugprint(DEBUG_FULL, "createchannel(): topic given was '%s', length '%ld'.\n", topic, strlen(topic));
+      debugprint(DEBUG_FULL, "createchannel(): topic set to '%s', length '%ld'.\n", channels[i].topic, strlen(channels[i].topic));
+      strncpy(channels[i].topicwho, topicwho, strlen(topicwho));
+      channels[i].topicwho[strlen(topicwho)] = '\0';
+      strncpy(channels[i].topicwhen, topicwhen, strlen(topicwhen));
+      channels[i].topicwhen[strlen(topicwhen)] = '\0';
+      channels[i].gotnames = 0;
+      return 1;
+      break; // TODO - This should be safe to remove since return is hit first
+    }
+  }
+
+  debugprint(DEBUG_CRIT, "error: createchannel() didn't create a channel\n");
+
+  // TODO - Make a failed return do something to callers
+  return 0;
+}
+
+int setchanneltopicwhotime(struct channel *channels, char *channelname, char *who, char *when) {
+  debugprint(DEBUG_FULL, "setchanneltopicwhotime(): given '%s', '%s', and '%s'.\n", channelname, who, when);
+
+  debugprint(DEBUG_FULL, "setchanneltopicwhotime(): who: '%s' with length '%ld'.\n", who, strlen(who));
+  debugprint(DEBUG_FULL, "setchanneltopicwhotime(): when: '%s' with length '%ld'.\n", when, strlen(when));
+
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (strncmp(channels[i].name, channelname, strlen(channelname)) == 0) {
+      strncpy(channels[i].topicwho, who, strlen(who));
+      channels[i].topicwho[strlen(who)] = '\0';
+      strncpy(channels[i].topicwhen, when, strlen(when));
+      channels[i].topicwhen[strlen(when)] = '\0';
+      return 1;
+    }
+  }
+
+  // TODO - Make a failed return do something to callers
+  return 0;
+}
+
+int setchanneltopic(struct channel *channels, char *channelname, char *topic) {
+  debugprint(DEBUG_FULL, "setchanneltopic(): given '%s' and '%s'.\n", channelname, topic);
+
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (strncmp(channels[i].name, channelname, strlen(channelname)) == 0) {
+      strncpy(channels[i].topic, topic, strlen(topic));
+      channels[i].topic[strlen(topic)] = '\0';
+      return 1;
+    }
+  }
+
+  // TODO - Make a failed return do something to callers
+  return 0;
+}
+
+int getchannelcount(struct channel *channels) {
+  int count = 0;
+
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (channels[i].name[0]) {
+      count++;
+    }
+  }
+
+  debugprint(DEBUG_FULL, "getchannelcount(): counted %d channels.\n", count);
+
+  return count;
+}
+
+int removechannel(struct channel *channels, char *name) {
+  debugprint(DEBUG_FULL, "removechannel(): given '%s'.\n", name);
+
+  // Clear its topic setter and timestamp...
+  setchanneltopicwhotime(channels, name, "", "0");
+
+  // Find the channel in the channel array...
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (strncmp(channels[i].name, name, strlen(name)) == 0) {
+      // ..and NULL its name (0th character = '\0')
+      channels[i].name[0] = '\0';
+      debugprint(DEBUG_FULL, "removechannel(): channel '%s' removed and topicwhen set to '%s'.\n", name, channels[i].topicwhen);
+      return 1;
+    }
+  }
+
+  debugprint(DEBUG_CRIT, "error: removechannel() didn't remove a channel\n");
+
+  // TODO - Make a failed return do something to callers
+  return 0;
+}
+
+// Check if we have the NAMES for the channel 'name' already.
+// Return the 1 if we do, 0 if we don't, or -1 if there's an error.
+int channelgotnames(struct channel *channels, char *name) {
+  debugprint(DEBUG_FULL, "channelgotnames(): given '%s'.\n", name);
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (strncmp(channels[i].name, name, strlen(name)) == 0) {
+      if (channels[i].gotnames) {
+        debugprint(DEBUG_FULL, "channelgotnames(): channel '%s' gotnames was set, returning '%d'.\n", channels[i].name, channels[i].gotnames);
+        return 1;
+      } else {
+        debugprint(DEBUG_FULL, "channelgotnames(): channel '%s' gotnames was not set, returning '%d'.\n", channels[i].name, channels[i].gotnames);
+        return 0;
+      }
+    }
+  }
+
+  // We didn't find the channel, this isn't good!  TODO - Do something if this happens.
+  debugprint(DEBUG_CRIT, "channelgotnames(): channel '%s' not found, this is bad, returning -1.\n", name);
+  return -1;
+}
+
+// Check if we are in a channel named "name" or not.
+// Return 1 if we are, or 0 if not.
+int inchannel(struct channel *channels, char *name) {
+  // Make sure the name doesn't have any trailing CR or LF
+  // (But only if name is at least two characters long already)
+  if (strlen(name) >= 2) {
+    while (name[strlen(name) - 1] == '\r' || name[strlen(name) - 1] == '\n') {
+      name[strlen(name) - 1] = '\0';
+    }
+  }
+
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (strncmp(channels[i].name, name, strlen(name)) == 0) {
+      debugprint(DEBUG_FULL, "inchannel(): in channel '%s'.\n", name);
+      return 1;
+    }
+  }
+
+  // We're not in the channel
+  debugprint(DEBUG_FULL, "inchannel(): NOT in channel '%s'.\n", name);
+  return 0;
+}
+
+// Returns the array index in the 'channels' array of the channel
+// named 'channel'.
+// Returns -1 if there was an error.
+int channelindex(struct channel *channels, char *name) {
+  debugprint(DEBUG_FULL, "channelindex(): given '%s'.\n", name);
+  for (int i = 0; i < MAXCHANNELS; i++) {
+    if (strncmp(channels[i].name, name, strlen(name)) == 0) {
+      return i;
+    }
+  }
+
+  // We didn't find the channel, this isn't good!  TODO - Do something if this happens.
+  debugprint(DEBUG_CRIT, "channelindex(): channel '%s' not found, this is bad, returning -1.\n", name);
+  return -1;
+}
+
+// Send the requested number of lines of replay log to the requested client
+// 'sourcefd' is the client to send to, and replayseconds is the number of
+// seconds of replay to replay.
+// Returns 1 for success or 0 for failure.
+int doreplay(int sourcefd, int replayseconds, struct client *clients, struct settings *settings, struct ircdstrings *ircdstrings, struct channel *channels) {
+  char outgoingmsg[MAXDATASIZE];
+
+  // Figure out how many lines to replay
+  int numlines = replaylines(replayseconds, settings->basedir);
+  debugprint(DEBUG_FULL, "Replay log lines: '%d'.\n", numlines);
+
+  if (numlines < 0) {
+    debugprint(DEBUG_CRIT, "Error getting number of replay lines.\n");
+    return 0;
+  } else if (numlines == 0) {
+    snprintf(outgoingmsg, MAXDATASIZE, "NOTICE %s :0 replay log lines found in the time requested, nothing to send.", ircdstrings->ircnick);
+    sendtoclient(sourcefd, outgoingmsg, clients, settings, 0);
+    return 1;
+  }
+
+  // Announce the start
+  snprintf(outgoingmsg, MAXDATASIZE, "NOTICE %s :Starting log replay....", ircdstrings->ircnick);
+  sendtoclient(sourcefd, outgoingmsg, clients, settings, 0);
+
+  // Replay those lines!
+  for (int i = 0; i < numlines; i++) {
+    if (!readreplayline(replayseconds, i, outgoingmsg, settings->basedir)) {
+      debugprint(DEBUG_CRIT, "Error requesting replay line.\n");
+      return 0;
+    }
+
+    // Check if the replay line is a TOPIC, a JOIN, or a PART so we don't
+    // replay those if we are not currently in the channel they are from
+    // otherwise clients and state go a bit mad.
+    // Never replay them if they are from us.
+
+    // Copy to a temporary string
+    char *strcopy = strdup(outgoingmsg);
+    // Keep track of initial pointer for free()ing later
+    char *strcopyPtr = strcopy;
+
+    // Build array of each space-separated token
+    char tokens[3][MAXDATASIZE];
+    char *token;
+
+    for (int j = 0; j < 3; j++) {
+      // Try to split
+      if ((token = strsep(&strcopy, " ")) == NULL) {
+        debugprint(DEBUG_CRIT, "doreplay(): error splitting string on iteration '%d', returning!\n", j);
+        return 0;
+      }
+      // Copy into the token array (strlen + 1 to get the NULL terminator)
+      strncpy(tokens[j], token, strlen(token) + 1);
+    }
+
+    if (strncmp(tokens[1], "TOPIC", strlen("TOPIC")) == 0 ||
+        strncmp(tokens[1], "JOIN", strlen("JOIN")) == 0 ||
+        strncmp(tokens[1], "PART", strlen("PART")) == 0) {
+      // Skip over colon if present in channel name
+      int offset = 0;
+      if (tokens[2][0] == ':') {
+        offset = 1;
+      }
+
+      // To make sure it's not us
+      extractnickfromprefix(tokens[0]);
+
+      // Check if we're currently in this channel or if the log line is from us
+      if (!inchannel(channels, tokens[2] + offset) || strncmp(tokens[0], ircdstrings->ircnick, strlen(tokens[0])) == 0) {
+        debugprint(DEBUG_FULL, "Not sending '%s' replay line '%s'.\n", tokens[1], outgoingmsg);
+        free(strcopyPtr);
+        continue;
+      }
+    }
+
+    free(strcopyPtr);
+
+    debugprint(DEBUG_FULL, "Sending replay line: '%s'.\n", outgoingmsg);
+    sendtoclient(sourcefd, outgoingmsg, clients, settings, 0);
+  }
+
+  // Announce the end
+  snprintf(outgoingmsg, MAXDATASIZE, "NOTICE %s :Log replay complete.", ircdstrings->ircnick);
+  sendtoclient(sourcefd, outgoingmsg, clients, settings, 0);
+
+  return 1;
+}
+
+// Return a count of the number of connected clients
+int numclients(struct client *clients) {
+  int count = 0;
+
+  for (int i = 0; i < MAXCLIENTS; i++) {
+    if (clients[i].fd) {
+      count++;
+    }
+  }
+
+  debugprint(DEBUG_FULL, "numclients(): '%d' clients connected.\n", count);
+  return count;
+}
+
+// Join any channels that were configured to be automatically
+// joined in the configuration file.
+// Returns 1 on success or 0 on failure.
+int joinautochannels(SSL *server_ssl, struct client *clients, struct settings *settings) {
+  if (strlen(settings->autochannels) == 0) {
+    // None configured
+    debugprint(DEBUG_FULL, "joinautochannels(): none configured.\n");
+    return 1;
+  }
+
+  // Split string up into each channel
+  char tokens[MAXAUTOCHANLEN][MAXCHANLENGTH];
+  int counter = 0;
+
+  // Copy to a temporary string
+  char *strcopy = strdup(settings->autochannels);
+  // Keep track of initial pointer for free()ing later
+  char *strcopyPtr = strcopy;
+
+  char *token;
+
+  // Split on commas
+  while ((token = strsep(&strcopy, ",")) != NULL) {
+    if (*token  == '\0') continue; // Skip consecutive matches
+    if (counter >= MAXAUTOCHANLEN) break; // Too many tokens
+    debugprint(DEBUG_FULL, "  >> Auto channel: '%s', length '%ld'.\n", token, strlen(token));
+    // Copy into the token array (strlen + 1 to get the NULL terminator)
+    strncpy(tokens[counter], token, strlen(token) + 1);
+    if (strlen(tokens[counter]) > MAXCHANLENGTH) {
+      printf("error: channel name '%s' from configuration file too long, max length is '%d'.\n", tokens[counter], MAXCHANLENGTH);
+      debugprint(DEBUG_CRIT, "error: channel name '%s' from configuration file too long, max length is '%d'.\n", tokens[counter], MAXCHANLENGTH);
+      exit(1);
+    }
+    counter++;
+  }
+
+  // Join all the channels
+  for (int i = 0; i < counter; i++) {
+    debugprint(DEBUG_FULL, "joinautochannels(): Joining '%s'.\n", tokens[i]);
+    char joinmsg[MAXDATASIZE];
+    snprintf(joinmsg, MAXDATASIZE, "JOIN %s", tokens[i]);
+    sendtoserver(server_ssl, joinmsg, strlen(joinmsg), 0, clients, settings);
+  }
+
+  free(strcopyPtr);
+  // TODO - Can we fail here?  Return 0 if so and make callers handle this if so.
+  return 1;
+}
+
+// Try to make a new nick if no configured are available or liked by the server
+// Do this by sticking a number on the end of the current nick and trying numbers
+// 1 through to 9.
+void tryautonick(struct ircdstrings *ircdstrings) {
+  // Increment the attempts counter
+  ircdstrings->autonicknum++;
+
+  if (ircdstrings->autonicknum == 10) {
+    // We've already tried 9 nicks and failed, give up
+    printf("tryautonick(): Tried 9 automatic nicks and the server didn't like any, giving up.\n");
+    debugprint(DEBUG_CRIT, "tryautonick(): Tried 9 automatic nicks and the server didn't like any, giving up.\n");
+    exit(1);
+  }
+
+  int oldlen = strlen(ircdstrings->ircnick);
+
+  // If we've already started trying autonick, just replace the last character a the new number
+  if (ircdstrings->autonicknum > 1) {
+    debugprint(DEBUG_FULL, "tryautonick(): already started autonick, starting with '%s' length '%ld'.\n", ircdstrings->ircnick, strlen(ircdstrings->ircnick));
+    ircdstrings->ircnick[oldlen - 1] = ircdstrings->autonicknum + '0';
+    // And null terminate
+    ircdstrings->ircnick[oldlen] = '\0';
+  // If the nick is longer than or equal to the RFC 1459 max nick
+  // length then try sticking the number at the end
+  } else if (oldlen >= MAXRFCNICKLEN) {
+    debugprint(DEBUG_FULL, "tryautonick(): long old nick, starting with '%s' length '%ld'.\n", ircdstrings->ircnick, strlen(ircdstrings->ircnick));
+    // (+ '0' to make char from int)
+    ircdstrings->ircnick[MAXRFCNICKLEN] = ircdstrings->autonicknum + '0';
+    // And null terminate
+    ircdstrings->ircnick[MAXRFCNICKLEN + 1] = '\0';
+  // Otherwise, just stick it on the end (+ '0' to make char from int)
+  } else {
+    debugprint(DEBUG_FULL, "tryautonick(): short old nick, starting with '%s' length '%ld'.\n", ircdstrings->ircnick, strlen(ircdstrings->ircnick));
+    ircdstrings->ircnick[oldlen] = ircdstrings->autonicknum + '0';
+    // And null terminate
+    ircdstrings->ircnick[oldlen + 1] = '\0';
+  }
+
+  debugprint(DEBUG_FULL, "tryautonick(): set irdstrings->ircnick to '%s'.\n", ircdstrings->ircnick);
+}