python socket_util: Don't try to unbind None bind_path.
[openvswitch] / python / ovs / socket_util.py
1 # Copyright (c) 2010, 2012 Nicira Networks
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at:
6 #
7 #     http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14
15 import errno
16 import os
17 import select
18 import socket
19 import sys
20
21 import ovs.fatal_signal
22 import ovs.vlog
23
24 vlog = ovs.vlog.Vlog("socket_util")
25
26
27 def make_unix_socket(style, nonblock, bind_path, connect_path):
28     """Creates a Unix domain socket in the given 'style' (either
29     socket.SOCK_DGRAM or socket.SOCK_STREAM) that is bound to 'bind_path' (if
30     'bind_path' is not None) and connected to 'connect_path' (if 'connect_path'
31     is not None).  If 'nonblock' is true, the socket is made non-blocking.
32
33     Returns (error, socket): on success 'error' is 0 and 'socket' is a new
34     socket object, on failure 'error' is a positive errno value and 'socket' is
35     None."""
36
37     try:
38         sock = socket.socket(socket.AF_UNIX, style)
39     except socket.error, e:
40         return get_exception_errno(e), None
41
42     try:
43         if nonblock:
44             set_nonblocking(sock)
45         if bind_path is not None:
46             # Delete bind_path but ignore ENOENT.
47             try:
48                 os.unlink(bind_path)
49             except OSError, e:
50                 if e.errno != errno.ENOENT:
51                     return e.errno, None
52
53             ovs.fatal_signal.add_file_to_unlink(bind_path)
54             sock.bind(bind_path)
55
56             try:
57                 if sys.hexversion >= 0x02060000:
58                     os.fchmod(sock.fileno(), 0700)
59                 else:
60                     os.chmod("/dev/fd/%d" % sock.fileno(), 0700)
61             except OSError, e:
62                 pass
63         if connect_path is not None:
64             try:
65                 sock.connect(connect_path)
66             except socket.error, e:
67                 if get_exception_errno(e) != errno.EINPROGRESS:
68                     raise
69         return 0, sock
70     except socket.error, e:
71         sock.close()
72         if bind_path is not None:
73             try:
74                 os.unlink(bind_path)
75             except OSError, e:
76                 pass
77             ovs.fatal_signal.add_file_to_unlink(bind_path)
78         return get_exception_errno(e), None
79
80
81 def check_connection_completion(sock):
82     p = select.poll()
83     p.register(sock, select.POLLOUT)
84     if len(p.poll(0)) == 1:
85         return get_socket_error(sock)
86     else:
87         return errno.EAGAIN
88
89
90 def get_socket_error(sock):
91     """Returns the errno value associated with 'socket' (0 if no error) and
92     resets the socket's error status."""
93     return sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
94
95
96 def get_exception_errno(e):
97     """A lot of methods on Python socket objects raise socket.error, but that
98     exception is documented as having two completely different forms of
99     arguments: either a string or a (errno, string) tuple.  We only want the
100     errno."""
101     if type(e.args) == tuple:
102         return e.args[0]
103     else:
104         return errno.EPROTO
105
106
107 null_fd = -1
108
109
110 def get_null_fd():
111     """Returns a readable and writable fd for /dev/null, if successful,
112     otherwise a negative errno value.  The caller must not close the returned
113     fd (because the same fd will be handed out to subsequent callers)."""
114     global null_fd
115     if null_fd < 0:
116         try:
117             null_fd = os.open("/dev/null", os.O_RDWR)
118         except OSError, e:
119             vlog.err("could not open /dev/null: %s" % os.strerror(e.errno))
120             return -e.errno
121     return null_fd
122
123
124 def write_fully(fd, buf):
125     """Returns an (error, bytes_written) tuple where 'error' is 0 on success,
126     otherwise a positive errno value, and 'bytes_written' is the number of
127     bytes that were written before the error occurred.  'error' is 0 if and
128     only if 'bytes_written' is len(buf)."""
129     bytes_written = 0
130     if len(buf) == 0:
131         return 0, 0
132     while True:
133         try:
134             retval = os.write(fd, buf)
135             assert retval >= 0
136             if retval == len(buf):
137                 return 0, bytes_written + len(buf)
138             elif retval == 0:
139                 vlog.warn("write returned 0")
140                 return errno.EPROTO, bytes_written
141             else:
142                 bytes_written += retval
143                 buf = buf[:retval]
144         except OSError, e:
145             return e.errno, bytes_written
146
147
148 def set_nonblocking(sock):
149     try:
150         sock.setblocking(0)
151     except socket.error, e:
152         vlog.err("could not set nonblocking mode on socket: %s"
153                  % os.strerror(get_socket_error(e)))