tests/client_util.c

   1 /*
   2  *  client_util.c: Utility functions for making test clients
   3  *  Copyright 2017 Simon Arlott
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  18  *  USA
  19  */
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include "tap/basic.h"
  25
  26 #include "client_util.h"
  27
  28 #include "hash.h"
  29 #include "s_newconf.h"
  30 #include "parse.h"
  31 #include "listener.h"
  32
  33 #define MSG "%s:%d (%s)", __FILE__, __LINE__, __FUNCTION__
  34
  35 static struct Listener fake_listener = {
  36         .next = NULL,
  37         .name = "fake",
  38         .F = NULL,
  39         .ref_count = 0,
  40         .active = 1,
  41         .ssl = 1,
  42         .defer_accept = 0,
  43         .sctp = false,
  44         .wsock = 0,
  45         .addr = {
  46                 { .ss_family = AF_INET6 },
  47                 { .ss_family = AF_INET6 },
  48         },
  49         .vhost = { "fake" },
  50 };
  51
  52 struct Client *make_local_unknown(void)
  53 {
  54         struct Client *client;
  55
  56         client = make_client(NULL);
  57         rb_dlinkMoveNode(&client->localClient->tnode, &unknown_list, &lclient_list);
  58         client->servptr = &me;
  59         rb_dlinkAdd(client, &client->lnode, &client->servptr->serv->users);
  60         client->localClient->listener = &fake_listener;
  61         client->preClient->auth.accepted = true;
  62
  63         return client;
  64 }
  65
  66 struct Client *make_local_person(void)
  67 {
  68         return make_local_person_nick(TEST_NICK);
  69 }
  70
  71 struct Client *make_local_person_nick(const char *nick)
  72 {
  73         return make_local_person_full(nick, TEST_USERNAME, TEST_HOSTNAME, TEST_IP, TEST_REALNAME);
  74 }
  75
  76 struct Client *make_local_person_full(const char *nick, const char *username, const char *hostname, const char *ip, const char *realname)
  77 {
  78         struct Client *client;
  79
  80         client = make_local_unknown();
  81         make_user(client);
  82         SetClient(client);
  83
  84         rb_inet_pton_sock(ip, &client->localClient->ip);
  85         rb_strlcpy(client->name, nick, sizeof(client->name));
  86         rb_strlcpy(client->username, username, sizeof(client->username));
  87         rb_strlcpy(client->host, hostname, sizeof(client->host));
  88         rb_inet_ntop_sock((struct sockaddr *)&client->localClient->ip, client->sockhost, sizeof(client->sockhost));
  89         rb_strlcpy(client->info, realname, sizeof(client->info));
  90
  91         add_to_client_hash(client->name, client);
  92
  93         return client;
  94 }
  95
  96 void make_local_person_oper(struct Client *client)
  97 {
  98         rb_dlinkAddAlloc(client, &local_oper_list);
  99         rb_dlinkAddAlloc(client, &oper_list);
 100         SetOper(client);
 101         struct PrivilegeSet *p = privilegeset_set_new("test", "test:test", 0);
 102         client->user->privset = privilegeset_ref(p);
 103 }
 104
 105 void remove_local_person(struct Client *client)
 106 {
 107         exit_client(NULL, client, &me, "Test client removed");
 108 }
 109
 110 struct Client *make_remote_server(struct Client *uplink)
 111 {
 112         return make_remote_server_name(uplink, TEST_SERVER_NAME);
 113 }
 114
 115 struct Client *make_remote_server_name(struct Client *uplink, const char *name)
 116 {
 117         return make_remote_server_full(uplink, name, "");
 118 }
 119
 120 struct Client *make_remote_server_full(struct Client *uplink, const char *name, const char *id)
 121 {
 122         struct Client *client;
 123
 124         client = make_client(NULL);
 125         client->servptr = uplink;
 126
 127         attach_server_conf(client, find_server_conf(name));
 128
 129         rb_strlcpy(client->name, name, sizeof(client->name));
 130         rb_strlcpy(client->id, id, sizeof(client->id));
 131
 132         rb_dlinkAdd(client, &client->lnode, &uplink->serv->servers);
 133         rb_dlinkMoveNode(&client->localClient->tnode, &unknown_list, &serv_list);
 134         rb_dlinkAddTailAlloc(client, &global_serv_list);
 135
 136         make_server(client);
 137         SetServer(client);
 138
 139         add_to_client_hash(client->name, client);
 140         if (strlen(id))
 141                 add_to_id_hash(client->id, client);
 142
 143         return client;
 144 }
 145
 146 struct Client *make_remote_person(struct Client *server)
 147 {
 148         return make_remote_person_nick(server, TEST_REMOTE_NICK);
 149 }
 150
 151 struct Client *make_remote_person_nick(struct Client *server, const char *nick)
 152 {
 153         return make_remote_person_full(server, nick, TEST_USERNAME, TEST_HOSTNAME, TEST_IP, TEST_REALNAME);
 154 }
 155
 156 struct Client *make_remote_person_full(struct Client *server, const char *nick, const char *username, const char *hostname, const char *ip, const char *realname)
 157 {
 158         struct Client *client;
 159         struct sockaddr_storage addr;
 160
 161         client = make_client(server);
 162         make_user(client);
 163         SetRemoteClient(client);
 164
 165         client->servptr = server;
 166         rb_dlinkAdd(server, &server->lnode, &server->servptr->serv->users);
 167
 168         rb_inet_pton_sock(ip, &addr);
 169         rb_strlcpy(client->name, nick, sizeof(client->name));
 170         rb_strlcpy(client->username, username, sizeof(client->username));
 171         rb_strlcpy(client->host, hostname, sizeof(client->host));
 172         rb_inet_ntop_sock((struct sockaddr *)&addr, client->sockhost, sizeof(client->sockhost));
 173         rb_strlcpy(client->info, realname, sizeof(client->info));
 174
 175         add_to_client_hash(nick, client);
 176         add_to_hostname_hash(client->host, client);
 177
 178         return client;
 179 }
 180
 181 void make_remote_person_oper(struct Client *client)
 182 {
 183         rb_dlinkAddAlloc(client, &oper_list);
 184         SetOper(client);
 185 }
 186
 187 void remove_remote_person(struct Client *client)
 188 {
 189         exit_client(client, client->servptr, client->servptr, "Test client removed");
 190 }
 191
 192 void remove_remote_server(struct Client *server)
 193 {
 194         exit_client(server, server, server->servptr, "Test server removed");
 195 }
 196
 197 struct Channel *make_channel(void)
 198 {
 199         return allocate_channel(TEST_CHANNEL);
 200 }
 201
 202 char *get_client_sendq(const struct Client *client)
 203 {
 204         static char buf[EXT_BUFSIZE + sizeof(CRLF)];
 205
 206         if (rb_linebuf_len(&client->localClient->buf_sendq)) {
 207                 int ret;
 208
 209                 memset(buf, 0, sizeof(buf));
 210                 ret = rb_linebuf_get(&client->localClient->buf_sendq, buf, sizeof(buf), 0, 1);
 211
 212                 if (ok(ret > 0, MSG)) {
 213                         return buf;
 214                 } else {
 215                         return "<get_client_sendq error>";
 216                 }
 217         }
 218
 219         return "";
 220 }
 221
 222 void client_util_parse(struct Client *client, const char *message)
 223 {
 224         char *copy = rb_strdup(message);
 225
 226         parse(client, copy, copy+strlen(copy));
 227
 228         rb_free(copy);
 229 }
 230
 231 void client_util_init(void)
 232 {
 233 }
 234
 235 void client_util_free(void)
 236 {
 237 }