usr.sbin/nscd/agents/services.c

   1 /*-
   2  * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include <sys/param.h>
  32 #include <sys/types.h>
  33 #include <assert.h>
  34 #include <nsswitch.h>
  35 #include <netdb.h>
  36 #include <string.h>
  37 #include <stdlib.h>
  38 #include "../debug.h"
  39 #include "services.h"
  40
  41 static int services_marshal_func(struct servent *, char *, size_t *);
  42 static int services_lookup_func(const char *, size_t, char **, size_t *);
  43 static void *services_mp_init_func();
  44 static int services_mp_lookup_func(char **, size_t *, void *);
  45 static void services_mp_destroy_func(void *);
  46
  47 static int
  48 services_marshal_func(struct servent *serv, char *buffer, size_t *buffer_size)
  49 {
  50         struct servent  new_serv;
  51         size_t  desired_size;
  52         char    **alias;
  53         char    *p;
  54         size_t  size;
  55         size_t  aliases_size;
  56
  57         TRACE_IN(services_marshal_func);
  58         desired_size = ALIGNBYTES + sizeof(struct servent) + sizeof(char *);
  59         if (serv->s_name != NULL)
  60                 desired_size += strlen(serv->s_name) + 1;
  61         if (serv->s_proto != NULL)
  62                 desired_size += strlen(serv->s_proto) + 1;
  63
  64         aliases_size = 0;
  65         if (serv->s_aliases != NULL) {
  66                 for (alias = serv->s_aliases; *alias; ++alias) {
  67                         desired_size += strlen(*alias) + 1;
  68                         ++aliases_size;
  69                 }
  70
  71                 desired_size += ALIGNBYTES + sizeof(char *) *
  72                     (aliases_size + 1);
  73         }
  74
  75         if ((*buffer_size < desired_size) || (buffer == NULL)) {
  76                 *buffer_size = desired_size;
  77                 TRACE_OUT(services_marshal_func);
  78                 return (NS_RETURN);
  79         }
  80
  81         memcpy(&new_serv, serv, sizeof(struct servent));
  82         memset(buffer, 0, desired_size);
  83
  84         *buffer_size = desired_size;
  85         p = buffer + sizeof(struct servent) + sizeof(char *);
  86         memcpy(buffer + sizeof(struct servent), &p, sizeof(char *));
  87         p = (char *)ALIGN(p);
  88
  89         if (new_serv.s_name != NULL) {
  90                 size = strlen(new_serv.s_name);
  91                 memcpy(p, new_serv.s_name, size);
  92                 new_serv.s_name = p;
  93                 p += size + 1;
  94         }
  95
  96         if (new_serv.s_proto != NULL) {
  97                 size = strlen(new_serv.s_proto);
  98                 memcpy(p, new_serv.s_proto, size);
  99                 new_serv.s_proto = p;
 100                 p += size + 1;
 101         }
 102
 103         if (new_serv.s_aliases != NULL) {
 104                 p = (char *)ALIGN(p);
 105                 memcpy(p, new_serv.s_aliases, sizeof(char *) * aliases_size);
 106                 new_serv.s_aliases = (char **)p;
 107                 p += sizeof(char *) * (aliases_size + 1);
 108
 109                 for (alias = new_serv.s_aliases; *alias; ++alias) {
 110                         size = strlen(*alias);
 111                         memcpy(p, *alias, size);
 112                         *alias = p;
 113                         p += size + 1;
 114                 }
 115         }
 116
 117         memcpy(buffer, &new_serv, sizeof(struct servent));
 118         TRACE_OUT(services_marshal_func);
 119         return (NS_SUCCESS);
 120 }
 121
 122 static int
 123 services_lookup_func(const char *key, size_t key_size, char **buffer,
 124         size_t *buffer_size)
 125 {
 126         enum nss_lookup_type lookup_type;
 127         char    *name = NULL;
 128         char    *proto = NULL;
 129         size_t  size, size2;
 130         int     port;
 131
 132         struct servent *result;
 133
 134         TRACE_IN(services_lookup_func);
 135
 136         assert(buffer != NULL);
 137         assert(buffer_size != NULL);
 138
 139         if (key_size < sizeof(enum nss_lookup_type)) {
 140                 TRACE_OUT(passwd_lookup_func);
 141                 return (NS_UNAVAIL);
 142         }
 143         memcpy(&lookup_type, key, sizeof(enum nss_lookup_type));
 144
 145         switch (lookup_type) {
 146         case nss_lt_name:
 147                 size = key_size - sizeof(enum nss_lookup_type);
 148                 name = (char *)calloc(1, size + 1);
 149                 assert(name != NULL);
 150                 memcpy(name, key + sizeof(enum nss_lookup_type), size);
 151
 152                 size2 = strlen(name) + 1;
 153
 154                 if (size2 < size)
 155                         proto = name + size2;
 156                 else
 157                         proto = NULL;
 158                 break;
 159         case nss_lt_id:
 160                 if (key_size < sizeof(enum nss_lookup_type) +
 161                         sizeof(int)) {
 162                         TRACE_OUT(passwd_lookup_func);
 163                         return (NS_UNAVAIL);
 164                 }
 165
 166                 memcpy(&port, key + sizeof(enum nss_lookup_type),
 167                         sizeof(int));
 168
 169                 size = key_size - sizeof(enum nss_lookup_type) - sizeof(int);
 170                 if (size > 0) {
 171                         proto = (char *)calloc(1, size + 1);
 172                         assert(proto != NULL);
 173                         memcpy(proto, key + sizeof(enum nss_lookup_type) +
 174                                 sizeof(int), size);
 175                 }
 176                 break;
 177         default:
 178                 TRACE_OUT(passwd_lookup_func);
 179                 return (NS_UNAVAIL);
 180         }
 181
 182         switch (lookup_type) {
 183         case nss_lt_name:
 184                 result = getservbyname(name, proto);
 185                 free(name);
 186                 break;
 187         case nss_lt_id:
 188                 result = getservbyport(port, proto);
 189                 free(proto);
 190                 break;
 191         default:
 192                 /* SHOULD NOT BE REACHED */
 193                 break;
 194         }
 195
 196         if (result != NULL) {
 197                 services_marshal_func(result, NULL, buffer_size);
 198                 *buffer = (char *)malloc(*buffer_size);
 199                 assert(*buffer != NULL);
 200                 services_marshal_func(result, *buffer, buffer_size);
 201         }
 202
 203         TRACE_OUT(services_lookup_func);
 204         return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
 205 }
 206
 207 static void *
 208 services_mp_init_func()
 209 {
 210         TRACE_IN(services_mp_init_func);
 211         setservent(0);
 212         TRACE_OUT(services_mp_init_func);
 213
 214         return (NULL);
 215 }
 216
 217 static int
 218 services_mp_lookup_func(char **buffer, size_t *buffer_size, void *mdata)
 219 {
 220         struct servent *result;
 221
 222         TRACE_IN(services_mp_lookup_func);
 223         result = getservent();
 224         if (result != NULL) {
 225                 services_marshal_func(result, NULL, buffer_size);
 226                 *buffer = (char *)malloc(*buffer_size);
 227                 assert(*buffer != NULL);
 228                 services_marshal_func(result, *buffer, buffer_size);
 229         }
 230
 231         TRACE_OUT(services_mp_lookup_func);
 232         return (result == NULL ? NS_NOTFOUND : NS_SUCCESS);
 233 }
 234
 235 static void
 236 services_mp_destroy_func(void *mdata)
 237 {
 238         TRACE_IN(services_mp_destroy_func);
 239         TRACE_OUT(services_mp_destroy_func);
 240 }
 241
 242 struct agent *
 243 init_services_agent()
 244 {
 245         struct common_agent     *retval;
 246         TRACE_IN(init_services_agent);
 247
 248         retval = (struct common_agent *)calloc(1, sizeof(struct common_agent));
 249         assert(retval != NULL);
 250
 251         retval->parent.name = strdup("services");
 252         assert(retval->parent.name != NULL);
 253
 254         retval->parent.type = COMMON_AGENT;
 255         retval->lookup_func = services_lookup_func;
 256
 257         TRACE_OUT(init_services_agent);
 258         return ((struct agent *)retval);
 259 }
 260
 261 struct agent *
 262 init_services_mp_agent()
 263 {
 264         struct multipart_agent  *retval;
 265
 266         TRACE_IN(init_services_mp_agent);
 267         retval = (struct multipart_agent *)calloc(1,
 268                 sizeof(struct multipart_agent));
 269         assert(retval != NULL);
 270
 271         retval->parent.name = strdup("services");
 272         retval->parent.type = MULTIPART_AGENT;
 273         retval->mp_init_func = services_mp_init_func;
 274         retval->mp_lookup_func = services_mp_lookup_func;
 275         retval->mp_destroy_func = services_mp_destroy_func;
 276         assert(retval->parent.name != NULL);
 277
 278         TRACE_OUT(init_services_mp_agent);
 279         return ((struct agent *)retval);
 280 }