rest25/library/socket.rst => rest262/library/socket.rst
2:mod:`socket` --- Low-level networking interface
3================================================
4
5.. module:: socket
6   :synopsis: Low-level networking interface.
7
8
9This module provides access to the BSD *socket* interface. It is available on
n10-all modern Unix systems, Windows, MacOS, BeOS, OS/2, and probably additional
n10+all modern Unix systems, Windows, Mac OS X, BeOS, OS/2, and probably additional
11platforms.
12
13.. note::
14
15   Some behavior may be platform dependent, since calls are made to the operating
16   system socket APIs.
17
18For an introduction to socket programming (in C), see the following papers: An
19Introductory 4.3BSD Interprocess Communication Tutorial, by Stuart Sechrest and
20An Advanced 4.3BSD Interprocess Communication Tutorial, by Samuel J.  Leffler et
21al, both in the UNIX Programmer's Manual, Supplementary Documents 1 (sections
22PS1:7 and PS1:8).  The platform-specific reference material for the various
23socket-related system calls are also a valuable source of information on the
24details of socket semantics.  For Unix, refer to the manual pages; for Windows,
25see the WinSock (or Winsock 2) specification. For IPv6-ready APIs, readers may
n26-want to refer to :rfc:`2553` titled Basic Socket Interface Extensions for IPv6.
n26+want to refer to :rfc:`3493` titled Basic Socket Interface Extensions for IPv6.
27
28.. index:: object: socket
29
30The Python interface is a straightforward transliteration of the Unix system
31call and library interface for sockets to Python's object-oriented style: the
32:func:`socket` function returns a :dfn:`socket object` whose methods implement
33the various socket system calls.  Parameter types are somewhat higher-level than
34in the C interface: as with :meth:`read` and :meth:`write` operations on Python
61returned from the DNS resolution.  The socket address will be resolved
62differently into an actual IPv4/v6 address, depending on the results from DNS
63resolution and/or the host configuration.  For deterministic behavior use a
64numeric address in *host* portion.
65
66.. versionadded:: 2.5
67   AF_NETLINK sockets are represented as  pairs ``pid, groups``.
68
n69+.. versionadded:: 2.6
70+   Linux-only support for TIPC is also available using the :const:`AF_TIPC`
71+   address family. TIPC is an open, non-IP based networked protocol designed
72+   for use in clustered computer environments.  Addresses are represented by a
73+   tuple, and the fields depend on the address type. The general tuple form is
74+   ``(addr_type, v1, v2, v3 [, scope])``, where:
75+ 
76+     - *addr_type* is one of TIPC_ADDR_NAMESEQ, TIPC_ADDR_NAME, or
77+       TIPC_ADDR_ID.
78+     - *scope* is one of TIPC_ZONE_SCOPE, TIPC_CLUSTER_SCOPE, and
79+       TIPC_NODE_SCOPE.
80+     - If *addr_type* is TIPC_ADDR_NAME, then *v1* is the server type, *v2* is
81+       the port identifier, and *v3* should be 0.
82+ 
83+       If *addr_type* is TIPC_ADDR_NAMESEQ, then *v1* is the server type, *v2*
84+       is the lower port number, and *v3* is the upper port number.
85+ 
86+       If *addr_type* is TIPC_ADDR_ID, then *v1* is the node, *v2* is the
87+       reference, and *v3* should be set to 0.
88+ 
89+ 
69All errors raise exceptions.  The normal exceptions for invalid argument types
70and out-of-memory conditions can be raised; errors related to socket or address
71semantics raise the error :exc:`socket.error`.
72
73Non-blocking mode is supported through :meth:`setblocking`.  A generalization of
74this based on timeouts is supported through :meth:`settimeout`.
75
76The module :mod:`socket` exports the following constants and functions:
80
81   .. index:: module: errno
82
83   This exception is raised for socket-related errors. The accompanying value is
84   either a string telling what went wrong or a pair ``(errno, string)``
85   representing an error returned by a system call, similar to the value
86   accompanying :exc:`os.error`. See the module :mod:`errno`, which contains names
87   for the error codes defined by the underlying operating system.
n109+ 
110+   .. versionchanged:: 2.6
111+      :exc:`socket.error` is now a child class of :exc:`IOError`.
88
89
90.. exception:: herror
91
92   This exception is raised for address-related errors, i.e. for functions that use
93   *h_errno* in the C API, including :func:`gethostbyname_ex` and
94   :func:`gethostbyaddr`.
95
153
154   Many constants of these forms, documented in the Unix documentation on sockets
155   and/or the IP protocol, are also defined in the socket module. They are
156   generally used in arguments to the :meth:`setsockopt` and :meth:`getsockopt`
157   methods of socket objects.  In most cases, only those symbols that are defined
158   in the Unix header files are defined; for a few symbols, default values are
159   provided.
160
n185+.. data:: SIO_*
186+          RCVALL_*
187+ 
188+   Constants for Windows' WSAIoctl(). The constants are used as arguments to the
189+   :meth:`ioctl` method of socket objects.
190+ 
191+   .. versionadded:: 2.6
192+ 
193+.. data:: TIPC_*
194+ 
195+   TIPC related constants, matching the ones exported by the C socket API. See
196+   the TIPC documentation for more information.
197+ 
198+   .. versionadded:: 2.6
161
162.. data:: has_ipv6
163
164   This constant contains a boolean value which indicates if IPv6 is supported on
165   this platform.
166
167   .. versionadded:: 2.3
168
169
n208+.. function:: create_connection(address[, timeout])
209+ 
210+   Convenience function.  Connect to *address* (a 2-tuple ``(host, port)``),
211+   and return the socket object.  Passing the optional *timeout* parameter will
212+   set the timeout on the socket instance before attempting to connect.  If no
213+   *timeout* is supplied, the global default timeout setting returned by
214+   :func:`getdefaulttimeout` is used.
215+ 
216+   .. versionadded:: 2.6
217+ 
218+ 
170.. function:: getaddrinfo(host, port[, family[, socktype[, proto[, flags]]]])
171
172   Resolves the *host*/*port* argument, into a sequence of 5-tuples that contain
n173-   all the necessary argument for the sockets manipulation. *host* is a domain
n222+   all the necessary arguments for creating the corresponding socket. *host* is a domain
174-   name, a string representation of IPv4/v6 address or ``None``. *port* is a string
223+   name, a string representation of an IPv4/v6 address or ``None``. *port* is a string
175-   service name (like ``'http'``), a numeric port number or ``None``.
224+   service name such as ``'http'``, a numeric port number or ``None``.
176- 
177-   The rest of the arguments are optional and must be numeric if specified.  For
225+   The rest of the arguments are optional and must be numeric if specified.
178-   *host* and *port*, by passing either an empty string or ``None``, you can pass
226+   By passing ``None`` as the value of *host* and *port*, , you can pass ``NULL`` to the C API.
179-   ``NULL`` to the C API.  The :func:`getaddrinfo` function returns a list of
227+ 
180-   5-tuples with the following structure:
228+   The :func:`getaddrinfo` function returns a list of 5-tuples with the following
229+   structure:
181
182   ``(family, socktype, proto, canonname, sockaddr)``
183
n184-   *family*, *socktype*, *proto* are all integer and are meant to be passed to the
n233+   *family*, *socktype*, *proto* are all integers and are meant to be passed to the
185   :func:`socket` function. *canonname* is a string representing the canonical name
186   of the *host*. It can be a numeric IPv4/v6 address when :const:`AI_CANONNAME` is
187   specified for a numeric *host*. *sockaddr* is a tuple describing a socket
n188-   address, as described above. See the source for the :mod:`httplib` and other
n237+   address, as described above. See the source for :mod:`socket` and other
189   library modules for a typical usage of the function.
190
191   .. versionadded:: 2.2
192
193
194.. function:: getfqdn([name])
195
196   Return a fully qualified domain name for *name*. If *name* is omitted or empty,
197   it is interpreted as the local host.  To find the fully qualified name, the
n198-   hostname returned by :func:`gethostbyaddr` is checked, then aliases for the
n247+   hostname returned by :func:`gethostbyaddr` is checked, followed by aliases for the
199   host, if available.  The first name which includes a period is selected.  In
200   case no fully qualified domain name is available, the hostname as returned by
201   :func:`gethostname` is returned.
202
203   .. versionadded:: 2.0
204
205
206.. function:: gethostbyname(hostname)
222   always a single address). :func:`gethostbyname_ex` does not support IPv6 name
223   resolution, and :func:`getaddrinfo` should be used instead for IPv4/v6 dual
224   stack support.
225
226
227.. function:: gethostname()
228
229   Return a string containing the hostname of the machine where  the Python
n230-   interpreter is currently executing. If you want to know the current machine's IP
n279+   interpreter is currently executing.
231-   address, you may want to use ``gethostbyname(gethostname())``. This operation
280+ 
232-   assumes that there is a valid address-to-host mapping for the host, and the
281+   If you want to know the current machine's IP address, you may want to use
233-   assumption does not always hold. Note: :func:`gethostname` doesn't always return
282+   ``gethostbyname(gethostname())``. This operation assumes that there is a
234-   the fully qualified domain name; use ``gethostbyaddr(gethostname())`` (see
283+   valid address-to-host mapping for the host, and the assumption does not
235-   below).
284+   always hold.
285+ 
286+   Note: :func:`gethostname` doesn't always return the fully qualified domain
287+   name; use ``getfqdn()`` (see above).
236
237
238.. function:: gethostbyaddr(ip_address)
239
240   Return a triple ``(hostname, aliaslist, ipaddrlist)`` where *hostname* is the
241   primary host name responding to the given *ip_address*, *aliaslist* is a
242   (possibly empty) list of alternative host names for the same address, and
243   *ipaddrlist* is a list of IPv4/v6 addresses for the same interface on the same
282.. function:: socket([family[, type[, proto]]])
283
284   Create a new socket using the given address family, socket type and protocol
285   number.  The address family should be :const:`AF_INET` (the default),
286   :const:`AF_INET6` or :const:`AF_UNIX`.  The socket type should be
287   :const:`SOCK_STREAM` (the default), :const:`SOCK_DGRAM` or perhaps one of the
288   other ``SOCK_`` constants.  The protocol number is usually zero and may be
289   omitted in that case.
n290- 
291- 
292-.. function:: ssl(sock[, keyfile, certfile])
293- 
294-   Initiate a SSL connection over the socket *sock*. *keyfile* is the name of a PEM
295-   formatted file that contains your private key. *certfile* is a PEM formatted
296-   certificate chain file. On success, a new :class:`SSLObject` is returned.
297- 
298-   .. warning::
299- 
300-      This does not do any certificate verification!
301
302
303.. function:: socketpair([family[, type[, proto]]])
304
305   Build a pair of connected socket objects using the given address family, socket
306   type, and protocol number.  Address family, socket type, and protocol number are
307   as for the :func:`socket` function above. The default family is :const:`AF_UNIX`
308   if defined on the platform; otherwise, the default is :const:`AF_INET`.
321   This function is rarely needed, but can be used to get or set socket options on
322   a socket passed to a program as standard input or output (such as a server
323   started by the Unix inet daemon).  The socket is assumed to be in blocking mode.
324   Availability: Unix.
325
326
327.. function:: ntohl(x)
328
n329-   Convert 32-bit integers from network to host byte order.  On machines where the
n370+   Convert 32-bit positive integers from network to host byte order.  On machines
330-   host byte order is the same as network byte order, this is a no-op; otherwise,
371+   where the host byte order is the same as network byte order, this is a no-op;
331-   it performs a 4-byte swap operation.
372+   otherwise, it performs a 4-byte swap operation.
332
333
334.. function:: ntohs(x)
335
n336-   Convert 16-bit integers from network to host byte order.  On machines where the
n377+   Convert 16-bit positive integers from network to host byte order.  On machines
337-   host byte order is the same as network byte order, this is a no-op; otherwise,
378+   where the host byte order is the same as network byte order, this is a no-op;
338-   it performs a 2-byte swap operation.
379+   otherwise, it performs a 2-byte swap operation.
339
340
341.. function:: htonl(x)
342
n343-   Convert 32-bit integers from host to network byte order.  On machines where the
n384+   Convert 32-bit positive integers from host to network byte order.  On machines
344-   host byte order is the same as network byte order, this is a no-op; otherwise,
385+   where the host byte order is the same as network byte order, this is a no-op;
345-   it performs a 4-byte swap operation.
386+   otherwise, it performs a 4-byte swap operation.
346
347
348.. function:: htons(x)
349
n350-   Convert 16-bit integers from host to network byte order.  On machines where the
n391+   Convert 16-bit positive integers from host to network byte order.  On machines
351-   host byte order is the same as network byte order, this is a no-op; otherwise,
392+   where the host byte order is the same as network byte order, this is a no-op;
352-   it performs a 2-byte swap operation.
393+   otherwise, it performs a 2-byte swap operation.
353
354
355.. function:: inet_aton(ip_string)
356
357   Convert an IPv4 address from dotted-quad string format (for example,
358   '123.45.67.89') to 32-bit packed binary format, as a string four characters in
359   length.  This is useful when conversing with a program that uses the standard C
360   library and needs objects of type :ctype:`struct in_addr`, which is the C type
543   are defined in this module.  If *buflen* is absent, an integer option is assumed
544   and its integer value is returned by the function.  If *buflen* is present, it
545   specifies the maximum length of the buffer used to receive the option in, and
546   this buffer is returned as a string.  It is up to the caller to decode the
547   contents of the buffer (see the optional built-in module :mod:`struct` for a way
548   to decode C structures encoded as strings).
549
550
n592+.. method:: socket.ioctl(control, option)
593+ 
594+   :platform: Windows
595+ 
596+   The :meth:`ioctl` method is a limited interface to the WSAIoctl system
597+   interface. Please refer to the MSDN documentation for more information.
598+ 
599+   .. versionadded:: 2.6
600+ 
601+ 
551.. method:: socket.listen(backlog)
552
553   Listen for connections made to the socket.  The *backlog* argument specifies the
554   maximum number of queued connections and should be at least 1; the maximum value
555   is system-dependent (usually 5).
556
557
558.. method:: socket.makefile([mode[, bufsize]])
559
560   .. index:: single: I/O control; buffering
561
562   Return a :dfn:`file object` associated with the socket.  (File objects are
n563-   described in :ref:`bltin-file-objects`, "File Objects.") The file object
n614+   described in :ref:`bltin-file-objects`.) The file object
564   references a :cfunc:`dup`\ ped version of the socket file descriptor, so the
565   file object and socket object may be closed or garbage-collected independently.
n566-   The socket must be in blocking mode. The optional *mode* and *bufsize* arguments
n617+   The socket must be in blocking mode (it can not have a timeout). The optional
567-   are interpreted the same way as by the built-in :func:`file` function; see
618+   *mode* and *bufsize* arguments are interpreted the same way as by the built-in
568-   "Built-in Functions" (section :ref:`built-in-funcs`) for more information.
619+   :func:`file` function.
569
570
571.. method:: socket.recv(bufsize[, flags])
572
573   Receive data from the socket.  The return value is a string representing the
574   data received.  The maximum amount of data to be received at once is specified
575   by *bufsize*.  See the Unix manual page :manpage:`recv(2)` for the meaning of
576   the optional argument *flags*; it defaults to zero.
580      For best match with hardware and network realities, the value of  *bufsize*
581      should be a relatively small power of 2, for example, 4096.
582
583
584.. method:: socket.recvfrom(bufsize[, flags])
585
586   Receive data from the socket.  The return value is a pair ``(string, address)``
587   where *string* is a string representing the data received and *address* is the
n588-   address of the socket sending the data.  The optional *flags* argument has the
n639+   address of the socket sending the data.  See the Unix manual page
589-   same meaning as for :meth:`recv` above. (The format of *address* depends on the
640+   :manpage:`recv(2)` for the meaning of the optional argument *flags*; it defaults
641+   to zero. (The format of *address* depends on the address family --- see above.)
642+ 
643+ 
644+.. method:: socket.recvfrom_into(buffer[, nbytes[, flags]])
645+ 
646+   Receive data from the socket, writing it into *buffer* instead of  creating a
647+   new string.  The return value is a pair ``(nbytes, address)`` where *nbytes* is
648+   the number of bytes received and *address* is the address of the socket sending
649+   the data.  See the Unix manual page :manpage:`recv(2)` for the meaning of the
650+   optional argument *flags*; it defaults to zero.  (The format of *address*
590-   address family --- see above.)
651+   depends on the address family --- see above.)
652+ 
653+   .. versionadded:: 2.5
654+ 
655+ 
656+.. method:: socket.recv_into(buffer[, nbytes[, flags]])
657+ 
658+   Receive up to *nbytes* bytes from the socket, storing the data into a buffer
659+   rather than creating a new string.     If *nbytes* is not specified (or 0),
660+   receive up to the size available in the given buffer. See the Unix manual page
661+   :manpage:`recv(2)` for the meaning of the optional argument *flags*; it defaults
662+   to zero.
663+ 
664+   .. versionadded:: 2.5
591
592
593.. method:: socket.send(string[, flags])
594
595   Send data to the socket.  The socket must be connected to a remote socket.  The
596   optional *flags* argument has the same meaning as for :meth:`recv` above.
597   Returns the number of bytes sent. Applications are responsible for checking that
598   all data has been sent; if only some of the data was transmitted, the
647   Return the timeout in floating seconds associated with socket operations, or
648   ``None`` if no timeout is set.  This reflects the last call to
649   :meth:`setblocking` or :meth:`settimeout`.
650
651   .. versionadded:: 2.3
652
653Some notes on socket blocking and timeouts: A socket object can be in one of
654three modes: blocking, non-blocking, or timeout.  Sockets are always created in
n655-blocking mode.  In blocking mode, operations block until complete.  In non-
n729+blocking mode.  In blocking mode, operations block until complete.  In
656-blocking mode, operations fail (with an error that is unfortunately system-
730+non-blocking mode, operations fail (with an error that is unfortunately
657-dependent) if they cannot be completed immediately.  In timeout mode, operations
731+system-dependent) if they cannot be completed immediately.  In timeout mode,
658-fail if they cannot be completed within the timeout specified for the socket.
732+operations fail if they cannot be completed within the timeout specified for the
659-The :meth:`setblocking` method is simply a shorthand for certain
733+socket.  The :meth:`setblocking` method is simply a shorthand for certain
660:meth:`settimeout` calls.
661
662Timeout mode internally sets the socket in non-blocking mode.  The blocking and
663timeout modes are shared between file descriptors and socket objects that refer
664to the same network endpoint.  A consequence of this is that file objects
665returned by the :meth:`makefile` method must only be used when the socket is in
666blocking mode; in timeout or non-blocking mode file operations that cannot be
667completed immediately will fail.
711   .. versionadded:: 2.5
712
713
714.. attribute:: socket.proto
715
716   The socket protocol.
717
718   .. versionadded:: 2.5
n719- 
720- 
721-.. _ssl-objects:
722- 
723-SSL Objects
724------------
725- 
726-SSL objects have the following methods.
727- 
728- 
729-.. method:: XXX Class.write(s)
730- 
731-   Writes the string *s* to the on the object's SSL connection. The return value is
732-   the number of bytes written.
733- 
734- 
735-.. method:: XXX Class.read([n])
736- 
737-   If *n* is provided, read *n* bytes from the SSL connection, otherwise read until
738-   EOF. The return value is a string of the bytes read.
739- 
740- 
741-.. method:: XXX Class.server()
742- 
743-   Returns a string containing the ASN.1 distinguished name identifying the
744-   server's certificate.  (See below for an example showing what distinguished
745-   names look like.)
746- 
747- 
748-.. method:: XXX Class.issuer()
749- 
750-   Returns a string containing the ASN.1 distinguished name identifying the issuer
751-   of the server's certificate.
752
753
754.. _socket-example:
755
756Example
757-------
758
759Here are four minimal example programs using the TCP/IP protocol: a server that
765:meth:`send`/:meth:`recv` on the  socket it is listening on but on the new
766socket returned by :meth:`accept`.
767
768The first two examples support IPv4 only. ::
769
770   # Echo server program
771   import socket
772
n773-   HOST = ''                 # Symbolic name meaning the local host
n814+   HOST = ''                 # Symbolic name meaning all available interfaces
774   PORT = 50007              # Arbitrary non-privileged port
775   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
776   s.bind((HOST, PORT))
777   s.listen(1)
778   conn, addr = s.accept()
779   print 'Connected by', addr
780   while 1:
781       data = conn.recv(1024)
803precedence and the server may not accept IPv4 traffic. The client side will try
804to connect to the all addresses returned as a result of the name resolution, and
805sends traffic to the first one connected successfully. ::
806
807   # Echo server program
808   import socket
809   import sys
810
n811-   HOST = ''                 # Symbolic name meaning the local host
n852+   HOST = None               # Symbolic name meaning all available interfaces
812   PORT = 50007              # Arbitrary non-privileged port
813   s = None
n814-   for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
n855+   for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,
856+                                 socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
815       af, socktype, proto, canonname, sa = res
816       try:
n817-        s = socket.socket(af, socktype, proto)
n859+           s = socket.socket(af, socktype, proto)
818       except socket.error, msg:
n819-        s = None
n861+           s = None
820-        continue
862+           continue
821       try:
n822-        s.bind(sa)
n864+           s.bind(sa)
823-        s.listen(1)
865+           s.listen(1)
824       except socket.error, msg:
n825-        s.close()
n867+           s.close()
826-        s = None
868+           s = None
827-        continue
869+           continue
828       break
829   if s is None:
830       print 'could not open socket'
831       sys.exit(1)
832   conn, addr = s.accept()
833   print 'Connected by', addr
834   while 1:
835       data = conn.recv(1024)
844   import sys
845
846   HOST = 'daring.cwi.nl'    # The remote host
847   PORT = 50007              # The same port as used by the server
848   s = None
849   for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
850       af, socktype, proto, canonname, sa = res
851       try:
n852-        s = socket.socket(af, socktype, proto)
n894+           s = socket.socket(af, socktype, proto)
853       except socket.error, msg:
n854-        s = None
n896+           s = None
855-        continue
897+           continue
856       try:
n857-        s.connect(sa)
n899+           s.connect(sa)
858       except socket.error, msg:
n859-        s.close()
n901+           s.close()
860-        s = None
902+           s = None
861-        continue
903+           continue
862       break
863   if s is None:
864       print 'could not open socket'
865       sys.exit(1)
866   s.send('Hello, world')
867   data = s.recv(1024)
868   s.close()
869   print 'Received', repr(data)
870
n871-This example connects to an SSL server, prints the  server and issuer's
n913+ 
872-distinguished names, sends some bytes, and reads part of the response::
914+The last example shows how to write a very simple network sniffer with raw
915+sockets on Windows. The example requires administrator privileges to modify
916+the interface::
873
874   import socket
875
n920+   # the public network interface
921+   HOST = socket.gethostbyname(socket.gethostname())
922+ 
923+   # create a raw socket and bind it to the public interface
876-   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
924+   s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
877-   s.connect(('www.verisign.com', 443))
925+   s.bind((HOST, 0))
878
n879-   ssl_sock = socket.ssl(s)
n927+   # Include IP headers
928+   s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
880
n881-   print repr(ssl_sock.server())
n930+   # receive all packages
882-   print repr(ssl_sock.issuer())
931+   s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
883
n884-   # Set a simple HTTP request -- use httplib in actual code.
n933+   # receive a package
885-   ssl_sock.write("""GET / HTTP/1.0\r
934+   print s.recvfrom(65565)
886-   Host: www.verisign.com\r\n\r\n""")
887
t888-   # Read a chunk of data.  Will not necessarily
t936+   # disabled promiscuous mode
889-   # read all the data returned by the server.
937+   s.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
890-   data = ssl_sock.read()
891- 
892-   # Note that you need to close the underlying socket, not the SSL object.
893-   del ssl_sock
894-   s.close()
895- 
896-At this writing, this SSL example prints the following output (line breaks
897-inserted for readability)::
898- 
899-   '/C=US/ST=California/L=Mountain View/
900-    O=VeriSign, Inc./OU=Production Services/
901-    OU=Terms of use at www.verisign.com/rpa (c)00/
902-    CN=www.verisign.com'
903-   '/O=VeriSign Trust Network/OU=VeriSign, Inc./
904-    OU=VeriSign International Server CA - Class 3/
905-    OU=www.verisign.com/CPS Incorp.by Ref. LIABILITY LTD.(c)97 VeriSign'
906- 
Legends
Colors
 Added 
Changed
Deleted
Links
(f)irst change
(n)ext change
(t)op