Line data    Source code

       1             : /*
       2             :  *  Unix SMB/CIFS implementation.
       3             :  *  Internal DNS query structures
       4             :  *  Copyright (C) Volker Lendecke 2018
       5             :  *
       6             :  *  This program is free software; you can redistribute it and/or modify
       7             :  *  it under the terms of the GNU General Public License as published by
       8             :  *  the Free Software Foundation; either version 3 of the License, or
       9             :  *  (at your option) any later version.
      10             :  *
      11             :  *  This program is distributed in the hope that it will be useful,
      12             :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             :  *  GNU General Public License for more details.
      15             :  *
      16             :  *  You should have received a copy of the GNU General Public License
      17             :  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
      18             :  */
      19             : 
      20             : #include "replace.h"
      21             : #include <stdio.h>
      22             : #include <errno.h>
      23             : #include "libcli/dns/resolvconf.h"
      24             : #include "lib/util/memory.h"
      25             : 
      26         199 : int parse_resolvconf_fp(
      27             :         FILE *fp,
      28             :         TALLOC_CTX *mem_ctx,
      29             :         char ***pnameservers,
      30             :         size_t *pnum_nameservers)
      31             : {
      32         199 :         char *line = NULL;
      33         199 :         size_t len = 0;
      34         199 :         char **nameservers = NULL;
      35         199 :         size_t num_nameservers = 0;
      36         199 :         int ret = 0;
      37             : 
      38         398 :         while (true) {
      39         597 :                 char *saveptr = NULL, *option = NULL, *ns = NULL;
      40         597 :                 char **tmp = NULL;
      41         597 :                 ssize_t n = 0;
      42             : 
      43         597 :                 n = getline(&line, &len, fp);
      44         597 :                 if (n < 0) {
      45         199 :                         if (!feof(fp)) {
      46             :                                 /* real error */
      47           0 :                                 ret = errno;
      48             :                         }
      49         333 :                         break;
      50             :                 }
      51         398 :                 if ((n > 0) && (line[n-1] == '\n')) {
      52         398 :                         line[n-1] = '\0';
      53             :                 }
      54             : 
      55         398 :                 if ((line[0] == '#') || (line[0] == ';')) {
      56           0 :                         continue;
      57             :                 }
      58             : 
      59         398 :                 option = strtok_r(line, " \t", &saveptr);
      60         398 :                 if (option == NULL) {
      61           0 :                         continue;
      62             :                 }
      63             : 
      64         398 :                 if (strcmp(option, "nameserver") != 0) {
      65           0 :                         continue;
      66             :                 }
      67             : 
      68         398 :                 ns = strtok_r(NULL, " \t", &saveptr);
      69         398 :                 if (ns == NULL) {
      70           0 :                         continue;
      71             :                 }
      72             : 
      73         398 :                 tmp = talloc_realloc(
      74             :                         mem_ctx,
      75             :                         nameservers,
      76             :                         char *,
      77             :                         num_nameservers+1);
      78         398 :                 if (tmp == NULL) {
      79           0 :                         ret = ENOMEM;
      80           0 :                         break;
      81             :                 }
      82         398 :                 nameservers = tmp;
      83             : 
      84         398 :                 nameservers[num_nameservers] = talloc_strdup(nameservers, ns);
      85         398 :                 if (nameservers[num_nameservers] == NULL) {
      86           0 :                         ret = ENOMEM;
      87           0 :                         break;
      88             :                 }
      89         398 :                 num_nameservers += 1;
      90             :         }
      91             : 
      92         333 :         SAFE_FREE(line);
      93             : 
      94         199 :         if (ret == 0) {
      95         199 :                 *pnameservers = nameservers;
      96         199 :                 *pnum_nameservers = num_nameservers;
      97             :         } else {
      98           0 :                 TALLOC_FREE(nameservers);
      99             :         }
     100             : 
     101         199 :         return ret;
     102             : }
     103             : 
     104           0 : int parse_resolvconf(
     105             :         const char *resolvconf,
     106             :         TALLOC_CTX *mem_ctx,
     107             :         char ***pnameservers,
     108             :         size_t *pnum_nameservers)
     109             : {
     110             :         FILE *fp;
     111             :         int ret;
     112             : 
     113           0 :         fp = fopen(resolvconf ? resolvconf : "/etc/resolv.conf", "r");
     114           0 :         if (fp == NULL) {
     115           0 :                 return errno;
     116             :         }
     117             : 
     118           0 :         ret = parse_resolvconf_fp(fp, mem_ctx, pnameservers, pnum_nameservers);
     119             : 
     120           0 :         fclose(fp);
     121             : 
     122           0 :         return ret;
     123             : }