Mac/Unsupported/mactcp/socket.py

   1 """socket.py for mac - Emulate socket module with mactcp and macdnr
   2
   3 Currently only implements TCP sockets (AF_INET, SOCK_STREAM).
   4 Esoteric things like socket options don't work,
   5 but getpeername() and makefile() do work; everything used by ftplib works!
   6 """
   7
   8 # Jack Jansen, CWI, November 1994 (initial version)
   9 # Guido van Rossum, CWI, March 1995 (bug fixes and lay-out)
  10
  11
  12 import mactcp
  13 import MACTCPconst
  14 import macdnr
  15
  16
  17 # Exported constants
  18
  19 _myerror = 'socket_wrapper.error'
  20 error = (mactcp.error, macdnr.error, _myerror)
  21
  22 SOCK_DGRAM = 1
  23 SOCK_STREAM = 2
  24
  25 AF_INET = 1
  26
  27
  28 # Internal constants
  29
  30 _BUFSIZE = 15*1024                      # Size of TCP/UDP input buffer
  31
  32 _myaddress = None
  33 _myname = None
  34 _myaddrstr = None
  35
  36
  37 def _myipaddress():
  38         global _myaddress
  39         if _myaddress == None:
  40                 _myaddress = mactcp.IPAddr()
  41         return _myaddress
  42
  43
  44 def _ipaddress(str):
  45         if type(str) == type(1):
  46                 return str                      # Already numeric
  47         ptr = macdnr.StrToAddr(str)
  48         ptr.wait()
  49         return ptr.ip0
  50
  51
  52 def gethostbyname(str):
  53         id = _ipaddress(str)
  54         return macdnr.AddrToStr(id)
  55
  56
  57 def gethostbyaddr(str):
  58         id = _ipaddress(str)
  59         ptr = macdnr.AddrToName(id)
  60         ptr.wait()
  61         name = ptr.cname
  62         if name[-1:] == '.': name = name[:-1]
  63         names, addresses = [], [str]
  64         return name, names, addresses
  65
  66 def gethostname():
  67         global _myname
  68         if _myname == None:
  69                 id = _myipaddress()
  70                 ptr = macdnr.AddrToName(id)
  71                 ptr.wait()
  72                 _myname = ptr.cname
  73         return _myname
  74
  75
  76 def _gethostaddress():
  77         global _myaddrstr
  78         if _myaddrstr == None:
  79                 id = _myipaddress()
  80                 _myaddrstr = macdnr.AddrToStr(id)
  81         return _myaddrstr
  82
  83
  84 def socket(family, type, *which):
  85         if family <> AF_INET:
  86                 raise _myerror, 'Protocol family %d not supported' % type
  87         if type == SOCK_DGRAM:
  88                 return _udpsocket()
  89         elif type == SOCK_STREAM:
  90                 return _tcpsocket()
  91         raise _myerror, 'Protocol type %d not supported' % type
  92
  93
  94 def fromfd(*args):
  95         raise _myerror, 'Operation not supported on a mac'
  96
  97
  98 class _socket:
  99         def unsupported(self, *args):
 100                 raise _myerror, 'Operation not supported on this socket'
 101
 102         accept = unsupported
 103         bind = unsupported
 104         close = unsupported
 105         connect = unsupported
 106         fileno = unsupported
 107         getpeername = unsupported
 108         getsockname = unsupported
 109         getsockopt = unsupported
 110         listen = unsupported
 111         recv = unsupported
 112         recvfrom = unsupported
 113         send = unsupported
 114         sendto = unsupported
 115         setblocking = unsupported
 116         setsockopt = unsupported
 117         shutdown = unsupported
 118
 119
 120 class _tcpsocket(_socket):
 121
 122         def __init__(self):
 123                 self.stream = mactcp.TCPCreate(_BUFSIZE)
 124                 ##self.stream.asr = self.asr
 125                 self.databuf = ''
 126                 self.udatabuf = ''
 127                 self.port = 0
 128                 self.accepted = 0
 129                 self.listening = 0
 130
 131         def accept(self):
 132                 if not self.listening:
 133                         raise _myerror, 'Not listening'
 134                 self.listening = 0
 135                 self.stream.wait()
 136                 self.accepted = 1
 137                 return self, self.getsockname()
 138
 139         # bind has two ways of calling: s.bind(host, port) or s.bind((host, port));
 140         # the latter is more proper but the former more common
 141         def bind(self, a1, a2=None):
 142                 if a2 is None:
 143                         host, port = a1
 144                 else:
 145                         host, port = a1, a2
 146                 self.port = port
 147
 148         def close(self):
 149                 if self.accepted:
 150                         self.accepted = 0
 151                         return
 152                 self.stream.Abort()
 153
 154         # connect has the same problem as bind (see above)
 155         def connect(self, a1, a2=None):
 156                 if a2 is None:
 157                         host, port = a1
 158                 else:
 159                         host, port = a1, a2
 160                 self.stream.ActiveOpen(self.port, _ipaddress(host), port)
 161
 162         def getsockname(self):
 163                 host, port = self.stream.GetSockName()
 164                 host = macdnr.AddrToStr(host)
 165                 return host, port
 166
 167         def getpeername(self):
 168                 st = self.stream.Status()
 169                 host = macdnr.AddrToStr(st.remoteHost)
 170                 return host, st.remotePort
 171
 172         def listen(self, backlog):
 173                 self.stream.PassiveOpen(self.port)
 174                 self.listening = 1
 175
 176         def makefile(self, rw = 'r', bs = 512):
 177                 return _socketfile(self, rw, bs)
 178
 179         def recv(self, bufsize, flags=0):
 180                 if flags:
 181                         raise _myerror, 'recv flags not yet supported on mac'
 182                 if not self.databuf:
 183                         try:
 184                                 self.databuf, urg, mark = self.stream.Rcv(0)
 185                         except mactcp.error, arg:
 186                                 if arg[0] != MACTCPconst.connectionClosing:
 187                                         raise mactcp.error, arg
 188                 rv = self.databuf[:bufsize]
 189                 self.databuf = self.databuf[bufsize:]
 190                 return rv
 191
 192         def send(self, buf):
 193                 self.stream.Send(buf)
 194                 return len(buf)
 195
 196         def shutdown(self, how):
 197                 if how == 0:
 198                         return
 199                 self.stream.Close()
 200
 201         def bytes_readable(self):
 202                 st = self.stream.Status()
 203                 return st.amtUnreadData
 204
 205         def bytes_writeable(self):
 206                 st = self.stream.Status()
 207                 return st.sendWindow - st.sendUnacked;
 208
 209
 210 class _udpsocket(_socket):
 211
 212         def __init__(self):
 213                 pass
 214
 215
 216 class _socketfile:
 217
 218         def __init__(self, sock, rw, bs):
 219                 if rw[1:] == 'b': rw = rw[:1]
 220                 if rw not in ('r', 'w'): raise _myerror, "mode must be 'r' or 'w'"
 221                 self.sock = sock
 222                 self.rw = rw
 223                 self.bs = bs
 224                 self.buf = ''
 225
 226         def read(self, length = -1):
 227                 if length < 0:
 228                         length = 0x7fffffff
 229                 while len(self.buf) < length:
 230                         new = self.sock.recv(0x7fffffff)
 231                         if not new:
 232                                 break
 233                         self.buf = self.buf + new
 234                 rv = self.buf[:length]
 235                 self.buf = self.buf[length:]
 236                 return rv
 237
 238         def readline(self):
 239                 import string
 240                 while not '\n' in self.buf:
 241                         new = self.sock.recv(0x7fffffff)
 242                         if not new:
 243                                 break
 244                         self.buf = self.buf + new
 245                 if not '\n' in self.buf:
 246                         rv = self.buf
 247                         self.buf = ''
 248                 else:
 249                         i = string.index(self.buf, '\n')
 250                         rv = self.buf[:i+1]
 251                         self.buf = self.buf[i+1:]
 252                 return rv
 253
 254         def readlines(self):
 255                 list = []
 256                 line = self.readline()
 257                 while line:
 258                         list.append(line)
 259                         line = self.readline()
 260                 return list
 261
 262         def write(self, buf):
 263                 BS = self.bs
 264                 if len(buf) >= BS:
 265                         self.flush()
 266                         self.sock.send(buf)
 267                 elif len(buf) + len(self.buf) >= BS:
 268                         self.flush()
 269                         self.buf = buf
 270                 else:
 271                         self.buf = self.buf + buf
 272
 273         def writelines(self, list):
 274                 for line in list:
 275                         self.write(line)
 276
 277         def flush(self):
 278                 if self.buf and self.rw == 'w':
 279                         self.sock.send(self.buf)
 280                         self.buf = ''
 281
 282         def close(self):
 283                 self.flush()
 284                 ##self.sock.close()
 285                 del self.sock
 286
 287
 288 def __test_tcp():
 289         s = socket(AF_INET, SOCK_STREAM)
 290         s.connect('poseidon.cwi.nl', 13)
 291         rv = s.recv(1000)
 292         print 'Time/date:', rv
 293         rv = s.recv(1000)
 294         if rv:
 295                 print 'Unexpected extra data:', rv
 296         s.close()
 297
 298
 299 def __test_udp():
 300         s = socket(AF_INET, SOCK_DGRAM)
 301         print 'Sending data... (hello world)'
 302         s.sendto(('poseidon.cwi.nl', 7), 'hello world')
 303         rv, host = s.recvfrom(1000)
 304         print 'Got from ', host, ':', rv