X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fsocket-util.c;h=7c1975061ff01d8fd7703c726c07e69bcd5514f6;hb=67a4917b07031b387beafaedce413b4207214059;hp=3d290e883a983a54191a53cee4677fb389b71b4c;hpb=064af42167bf4fc9aaea2702d80ce08074b889c0;p=sliver-openvswitch.git diff --git a/lib/socket-util.c b/lib/socket-util.c index 3d290e883..7c1975061 100644 --- a/lib/socket-util.c +++ b/lib/socket-util.c @@ -1,17 +1,17 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010 Nicira Networks. * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. */ #include @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -72,25 +73,16 @@ get_max_fds(void) return max_fds; } -/* Translates 'host_name', which may be a DNS name or an IP address, into a - * numeric IP address in '*addr'. Returns 0 if successful, otherwise a - * positive errno value. */ +/* Translates 'host_name', which must be a string representation of an IP + * address, into a numeric IP address in '*addr'. Returns 0 if successful, + * otherwise a positive errno value. */ int lookup_ip(const char *host_name, struct in_addr *addr) { if (!inet_aton(host_name, addr)) { - struct hostent *he = gethostbyname(host_name); - if (he == NULL) { - struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); - VLOG_ERR_RL(&rl, "gethostbyname(%s): %s", host_name, - (h_errno == HOST_NOT_FOUND ? "host not found" - : h_errno == TRY_AGAIN ? "try again" - : h_errno == NO_RECOVERY ? "non-recoverable error" - : h_errno == NO_ADDRESS ? "no address" - : "unknown error")); - return ENOENT; - } - addr->s_addr = *(uint32_t *) he->h_addr; + struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); + VLOG_ERR_RL(&rl, "\"%s\" is not a valid IP address", host_name); + return ENOENT; } return 0; } @@ -212,7 +204,7 @@ make_sockaddr_un(const char *name, struct sockaddr_un* un, socklen_t *un_len) * * Returns the socket's fd if successful, otherwise a negative errno value. */ int -make_unix_socket(int style, bool nonblock, bool passcred UNUSED, +make_unix_socket(int style, bool nonblock, bool passcred OVS_UNUSED, const char *bind_path, const char *connect_path) { int error; @@ -299,6 +291,204 @@ guess_netmask(uint32_t ip) : htonl(0)); /* ??? */ } +/* Opens a non-blocking IPv4 socket of the specified 'style' and connects to + * 'target', which should be a string in the format "[:]". + * is required. If 'default_port' is nonzero then is optional and + * defaults to 'default_port'. + * + * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP). + * + * On success, returns 0 (indicating connection complete) or EAGAIN (indicating + * connection in progress), in which case the new file descriptor is stored + * into '*fdp'. On failure, returns a positive errno value other than EAGAIN + * and stores -1 into '*fdp'. + * + * If 'sinp' is non-null, then on success the target address is stored into + * '*sinp'. */ +int +inet_open_active(int style, const char *target_, uint16_t default_port, + struct sockaddr_in *sinp, int *fdp) +{ + char *target = xstrdup(target_); + char *save_ptr = NULL; + const char *host_name; + const char *port_string; + struct sockaddr_in sin; + int fd = -1; + int error; + + /* Defaults. */ + memset(&sin, 0, sizeof sin); + sin.sin_family = AF_INET; + sin.sin_port = htons(default_port); + + /* Tokenize. */ + host_name = strtok_r(target, ":", &save_ptr); + port_string = strtok_r(NULL, ":", &save_ptr); + if (!host_name) { + ovs_error(0, "%s: bad peer name format", target_); + error = EAFNOSUPPORT; + goto exit; + } + + /* Look up IP, port. */ + error = lookup_ip(host_name, &sin.sin_addr); + if (error) { + goto exit; + } + if (port_string && atoi(port_string)) { + sin.sin_port = htons(atoi(port_string)); + } else if (!default_port) { + VLOG_ERR("%s: port number must be specified", target_); + error = EAFNOSUPPORT; + goto exit; + } + + /* Create non-blocking socket. */ + fd = socket(AF_INET, style, 0); + if (fd < 0) { + VLOG_ERR("%s: socket: %s", target_, strerror(errno)); + error = errno; + goto exit; + } + error = set_nonblocking(fd); + if (error) { + goto exit_close; + } + + /* Connect. */ + error = connect(fd, (struct sockaddr *) &sin, sizeof sin) == 0 ? 0 : errno; + if (error == EINPROGRESS) { + error = EAGAIN; + } else if (error && error != EAGAIN) { + goto exit_close; + } + + /* Success: error is 0 or EAGAIN. */ + goto exit; + +exit_close: + close(fd); +exit: + if (!error || error == EAGAIN) { + if (sinp) { + *sinp = sin; + } + *fdp = fd; + } else { + *fdp = -1; + } + free(target); + return error; +} + +/* Opens a non-blocking IPv4 socket of the specified 'style', binds to + * 'target', and listens for incoming connections. 'target' should be a string + * in the format "[][:]". may be omitted if 'default_port' is + * nonzero, in which case it defaults to 'default_port'. If is omitted it + * defaults to the wildcard IP address. + * + * 'style' should be SOCK_STREAM (for TCP) or SOCK_DGRAM (for UDP). + * + * For TCP, the socket will have SO_REUSEADDR turned on. + * + * On success, returns a non-negative file descriptor. On failure, returns a + * negative errno value. */ +int +inet_open_passive(int style, const char *target_, uint16_t default_port) +{ + char *target = xstrdup(target_); + char *string_ptr = target; + struct sockaddr_in sin; + const char *host_name; + const char *port_string; + int fd, error; + unsigned int yes = 1; + + /* Address defaults. */ + memset(&sin, 0, sizeof sin); + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = htonl(INADDR_ANY); + sin.sin_port = htons(default_port); + + /* Parse optional port number. */ + port_string = strsep(&string_ptr, ":"); + if (port_string && atoi(port_string)) { + sin.sin_port = htons(atoi(port_string)); + } else if (!default_port) { + VLOG_ERR("%s: port number must be specified", target_); + error = EAFNOSUPPORT; + goto exit; + } + + /* Parse optional bind IP. */ + host_name = strsep(&string_ptr, ":"); + if (host_name && host_name[0]) { + error = lookup_ip(host_name, &sin.sin_addr); + if (error) { + goto exit; + } + } + + /* Create non-blocking socket, set SO_REUSEADDR. */ + fd = socket(AF_INET, style, 0); + if (fd < 0) { + error = errno; + VLOG_ERR("%s: socket: %s", target_, strerror(error)); + goto exit; + } + error = set_nonblocking(fd); + if (error) { + goto exit_close; + } + if (style == SOCK_STREAM + && setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0) { + error = errno; + VLOG_ERR("%s: setsockopt(SO_REUSEADDR): %s", target_, strerror(error)); + goto exit_close; + } + + /* Bind. */ + if (bind(fd, (struct sockaddr *) &sin, sizeof sin) < 0) { + error = errno; + VLOG_ERR("%s: bind: %s", target_, strerror(error)); + goto exit_close; + } + + /* Listen. */ + if (listen(fd, 10) < 0) { + error = errno; + VLOG_ERR("%s: listen: %s", target_, strerror(error)); + goto exit_close; + } + error = 0; + goto exit; + +exit_close: + close(fd); +exit: + free(target); + return error ? -error : fd; +} + +/* Returns a readable and writable fd for /dev/null, if successful, otherwise + * a negative errno value. The caller must not close the returned fd (because + * the same fd will be handed out to subsequent callers). */ +int +get_null_fd(void) +{ + static int null_fd = -1; + if (null_fd < 0) { + null_fd = open("/dev/null", O_RDWR); + if (null_fd < 0) { + int error = errno; + VLOG_ERR("could not open /dev/null: %s", strerror(error)); + return -error; + } + } + return null_fd; +} + int read_fully(int fd, void *p_, size_t size, size_t *bytes_read) {