1

#include <stdio.h>

     2

#include <ctype.h>

     3

     4

#include "config.h"

     5

#include "common.h"

     6

     7

void endpoint_init (struct config_endpoint *endpoint, unsigned short default_port) {

     8

    // snprintf the default port as a string

     9

    snprintf(endpoint->_data.default_port, PORT_TEXT_LEN, "%hu", default_port);

    10

    11

    // set up defaults

    12

    endpoint->family = PF_INET;

    13

    endpoint->af.inet.addr = NULL;

    14

    endpoint->af.inet.port = endpoint->_data.default_port;

    15

}

    16

    17

/*

    18

 * Parse an endpoint address in human-readable format into the given endpoint. You can then use the socket_*

    19

 * functions to work with endpoints and sockets.

    20

 *

    21

 * Formats supported:

    22

 *  =foo.sock, =/quux/bar.sock

    23

 *  hostname, 12.34.56.78, [::1]

    24

 *  hostname:port, 12.34.56.78:port, [::1]:port

    25

 */

    26

int endpoint_parse (struct config_endpoint *endpoint, const char *addr_spec) {

    27

    // for empty addr specs, just return

    28

    if (!addr_spec || *addr_spec == '\0')

    29

        return 1;

    30

    31

    if (sscanf(addr_spec, "=%" PATH_TEXT_LEN_STR "s", endpoint->_data.path) == 1) {

    32

        // local unix socket

    33

        endpoint->family = PF_LOCAL;

    34

        endpoint->af.local.path =  endpoint->_data.path;

    35

    36

    } else if (

    37

            sscanf(addr_spec, "[%" ADDR_TEXT_LEN_STR "[^]] ]:%" PORT_TEXT_LEN_STR "s", endpoint->_data.addr, endpoint->_data.port) == 2

    38

        ||  sscanf(addr_spec, "%" ADDR_TEXT_LEN_STR "[^:] :%" PORT_TEXT_LEN_STR "s", endpoint->_data.addr, endpoint->_data.port) == 2

    39

    ) {

    40

        endpoint->family = PF_INET;

    41

        endpoint->af.inet.addr = endpoint->_data.addr;

    42

        endpoint->af.inet.port = endpoint->_data.port;

    43

    44

    } else if (

    45

            sscanf(addr_spec, "[%" ADDR_TEXT_LEN_STR "[^]] ]", endpoint->_data.addr) == 1

    46

        ||  sscanf(addr_spec, "%" ADDR_TEXT_LEN_STR "[^:]", endpoint->_data.addr) == 1

    47

    ) {

    48

        endpoint->family = PF_INET;

    49

        endpoint->af.inet.addr = endpoint->_data.addr;

    50

    51

    } else {

    52

        // unknown foramt

    53

        ERROR("unkown address format: %s", addr_spec);

    54

    }

    55

    56

    return 0;

    57

    58

error:

    59

    return -1;

    60

}

    61

    62

int parse_hostport (char *hostport, char **host, char **port) {

    63

    char *c;

    64

    65

    int brace = 0, colon = 0;

    66

    *host = *port = NULL;

    67

    68

    for (c = hostport; *c != '\0'; c++) {

    69

        if (isspace(*c))

    70

            continue;

    71

    72

        switch (*c) {

    73

            case '[':

    74

                if (c > hostport) {

    75

                    error("parse_hostport: %c must be first char, if any: %s", *c, hostport);

    76

                    return -1;

    77

                }

    78

    79

                brace = *c;

    80

                break;

    81

    82

            case ']':

    83

                if (!brace) {

    84

                    error("parse_hostport: %c without matching brace: %s", *c, hostport);

    85

                    return -1;

    86

                }

    87

    88

                if (!*host) {

    89

                    error("parse_hostport: empty hostname: %s", hostport);

    90

                    return -1;

    91

                }

    92

    93

                brace = 0;

    94

                break;

    95

    96

            case ':':

    97

                if (brace) {

    98

                    // colons inside braces are left as-is

    99

                    continue;

   100

                }

   101

   102

                if (!*host) {

   103

                    error("parse_hostport: colon before hostname: %s", hostport);

   104

                    return -1;

   105

                }

   106

   107

                if (*port) {

   108

                    error("parse_hostport: colon after port: %s", hostport);

   109

                    return -1;

   110

                }

   111

   112

                if (colon) {

   113

                    error("parse_hostport: too many colons: %s", hostport);

   114

                    return -1;

   115

                };

   116

   117

                // finished parsing the host part, move on to the port part

   118

                colon = ':';

   119

                *c = '\0';

   120

                break;

   121

   122

            default:

   123

                if (!*host) {

   124

                    // first char of the host

   125

                    *host = c;

   126

   127

                } else if (colon && !*port) {

   128

                    // first char of the port

   129

                    *port = c;

   130

   131

                } // else a part of either, don't care about it

   132

   133

                break;

   134

        }

   135

    }

   136

   137

    if (!*host) {

   138

        error("parse_hostport: missing hostname: %s", hostport);

   139

        return -1;

   140

    }

   141

   142

    if (brace) {

   143

        error("parse_hostport: missing close-brace for %c: %s", brace, hostport);

   144

        return -1;

   145

    }

   146

   147

    if (colon && !*port) {

   148

        error("parse_hostport: missing port: %s", hostport);

   149

        return -1;

   150

    }

   151

   152

    return 0;

   153

}