Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 1 | """An NNTP client class based on: |
| 2 | - RFC 977: Network News Transfer Protocol |
| 3 | - RFC 2980: Common NNTP Extensions |
| 4 | - RFC 3977: Network News Transfer Protocol (version 2) |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 5 | |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 6 | Example: |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 7 | |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 8 | >>> from nntplib import NNTP |
| 9 | >>> s = NNTP('news') |
| 10 | >>> resp, count, first, last, name = s.group('comp.lang.python') |
Guido van Rossum | 7131f84 | 2007-02-09 20:13:25 +0000 | [diff] [blame] | 11 | >>> print('Group', name, 'has', count, 'articles, range', first, 'to', last) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 12 | Group comp.lang.python has 51 articles, range 5770 to 5821 |
Christian Heimes | 933238a | 2008-11-05 19:44:21 +0000 | [diff] [blame] | 13 | >>> resp, subs = s.xhdr('subject', '{0}-{1}'.format(first, last)) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 14 | >>> resp = s.quit() |
| 15 | >>> |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 16 | |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 17 | Here 'resp' is the server response line. |
| 18 | Error responses are turned into exceptions. |
| 19 | |
| 20 | To post an article from a file: |
Christian Heimes | 933238a | 2008-11-05 19:44:21 +0000 | [diff] [blame] | 21 | >>> f = open(filename, 'rb') # file containing article, including header |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 22 | >>> resp = s.post(f) |
| 23 | >>> |
| 24 | |
| 25 | For descriptions of all methods, read the comments in the code below. |
| 26 | Note that all arguments and return values representing article numbers |
| 27 | are strings, not numbers, since they are rarely used for calculations. |
| 28 | """ |
| 29 | |
| 30 | # RFC 977 by Brian Kantor and Phil Lapsley. |
| 31 | # xover, xgtitle, xpath, date methods by Kevan Heydon |
Guido van Rossum | 8421c4e | 1995-09-22 00:52:38 +0000 | [diff] [blame] | 32 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 33 | # Incompatible changes from the 2.x nntplib: |
| 34 | # - all commands are encoded as UTF-8 data (using the "surrogateescape" |
| 35 | # error handler), except for raw message data (POST, IHAVE) |
| 36 | # - all responses are decoded as UTF-8 data (using the "surrogateescape" |
| 37 | # error handler), except for raw message data (ARTICLE, HEAD, BODY) |
| 38 | # - the `file` argument to various methods is keyword-only |
| 39 | # |
| 40 | # - NNTP.date() returns a datetime object |
| 41 | # - NNTP.newgroups() and NNTP.newnews() take a datetime (or date) object, |
| 42 | # rather than a pair of (date, time) strings. |
| 43 | # - NNTP.newgroups() and NNTP.list() return a list of GroupInfo named tuples |
| 44 | # - NNTP.descriptions() returns a dict mapping group names to descriptions |
| 45 | # - NNTP.xover() returns a list of dicts mapping field names (header or metadata) |
| 46 | # to field values; each dict representing a message overview. |
| 47 | # - NNTP.article(), NNTP.head() and NNTP.body() return a (response, ArticleInfo) |
| 48 | # tuple. |
| 49 | # - the "internal" methods have been marked private (they now start with |
| 50 | # an underscore) |
| 51 | |
| 52 | # Other changes from the 2.x/3.1 nntplib: |
| 53 | # - automatic querying of capabilities at connect |
| 54 | # - New method NNTP.getcapabilities() |
| 55 | # - New method NNTP.over() |
| 56 | # - New helper function decode_header() |
| 57 | # - NNTP.post() and NNTP.ihave() accept file objects, bytes-like objects and |
| 58 | # arbitrary iterables yielding lines. |
| 59 | # - An extensive test suite :-) |
| 60 | |
| 61 | # TODO: |
| 62 | # - return structured data (GroupInfo etc.) everywhere |
| 63 | # - support HDR |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 64 | |
| 65 | # Imports |
Guido van Rossum | 9694fca | 1997-10-22 21:00:49 +0000 | [diff] [blame] | 66 | import re |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 67 | import socket |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 68 | import collections |
| 69 | import datetime |
| 70 | import warnings |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 71 | |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 72 | try: |
| 73 | import ssl |
| 74 | except ImportError: |
| 75 | _have_ssl = False |
| 76 | else: |
| 77 | _have_ssl = True |
| 78 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 79 | from email.header import decode_header as _email_decode_header |
| 80 | from socket import _GLOBAL_DEFAULT_TIMEOUT |
| 81 | |
| 82 | __all__ = ["NNTP", |
| 83 | "NNTPReplyError", "NNTPTemporaryError", "NNTPPermanentError", |
| 84 | "NNTPProtocolError", "NNTPDataError", |
| 85 | "decode_header", |
| 86 | ] |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 87 | |
Barry Warsaw | 9dd7872 | 2000-02-10 20:25:53 +0000 | [diff] [blame] | 88 | # Exceptions raised when an error or invalid response is received |
| 89 | class NNTPError(Exception): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 90 | """Base class for all nntplib exceptions""" |
| 91 | def __init__(self, *args): |
Guido van Rossum | 68468eb | 2003-02-27 20:14:51 +0000 | [diff] [blame] | 92 | Exception.__init__(self, *args) |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 93 | try: |
| 94 | self.response = args[0] |
| 95 | except IndexError: |
| 96 | self.response = 'No response given' |
Barry Warsaw | 9dd7872 | 2000-02-10 20:25:53 +0000 | [diff] [blame] | 97 | |
| 98 | class NNTPReplyError(NNTPError): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 99 | """Unexpected [123]xx reply""" |
| 100 | pass |
Barry Warsaw | 9dd7872 | 2000-02-10 20:25:53 +0000 | [diff] [blame] | 101 | |
| 102 | class NNTPTemporaryError(NNTPError): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 103 | """4xx errors""" |
| 104 | pass |
Barry Warsaw | 9dd7872 | 2000-02-10 20:25:53 +0000 | [diff] [blame] | 105 | |
| 106 | class NNTPPermanentError(NNTPError): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 107 | """5xx errors""" |
| 108 | pass |
Barry Warsaw | 9dd7872 | 2000-02-10 20:25:53 +0000 | [diff] [blame] | 109 | |
| 110 | class NNTPProtocolError(NNTPError): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 111 | """Response does not begin with [1-5]""" |
| 112 | pass |
Barry Warsaw | 9dd7872 | 2000-02-10 20:25:53 +0000 | [diff] [blame] | 113 | |
| 114 | class NNTPDataError(NNTPError): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 115 | """Error in response data""" |
| 116 | pass |
Barry Warsaw | 9dd7872 | 2000-02-10 20:25:53 +0000 | [diff] [blame] | 117 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 118 | |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 119 | # Standard port used by NNTP servers |
| 120 | NNTP_PORT = 119 |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 121 | NNTP_SSL_PORT = 563 |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 122 | |
| 123 | # Response numbers that are followed by additional text (e.g. article) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 124 | _LONGRESP = { |
| 125 | '100', # HELP |
| 126 | '101', # CAPABILITIES |
| 127 | '211', # LISTGROUP (also not multi-line with GROUP) |
| 128 | '215', # LIST |
| 129 | '220', # ARTICLE |
| 130 | '221', # HEAD, XHDR |
| 131 | '222', # BODY |
| 132 | '224', # OVER, XOVER |
| 133 | '225', # HDR |
| 134 | '230', # NEWNEWS |
| 135 | '231', # NEWGROUPS |
| 136 | '282', # XGTITLE |
| 137 | } |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 138 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 139 | # Default decoded value for LIST OVERVIEW.FMT if not supported |
| 140 | _DEFAULT_OVERVIEW_FMT = [ |
| 141 | "subject", "from", "date", "message-id", "references", ":bytes", ":lines"] |
| 142 | |
| 143 | # Alternative names allowed in LIST OVERVIEW.FMT response |
| 144 | _OVERVIEW_FMT_ALTERNATIVES = { |
| 145 | 'bytes': ':bytes', |
| 146 | 'lines': ':lines', |
| 147 | } |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 148 | |
| 149 | # Line terminators (we always output CRLF, but accept any of CRLF, CR, LF) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 150 | _CRLF = b'\r\n' |
| 151 | |
| 152 | GroupInfo = collections.namedtuple('GroupInfo', |
| 153 | ['group', 'last', 'first', 'flag']) |
| 154 | |
| 155 | ArticleInfo = collections.namedtuple('ArticleInfo', |
| 156 | ['number', 'message_id', 'lines']) |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 157 | |
| 158 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 159 | # Helper function(s) |
| 160 | def decode_header(header_str): |
| 161 | """Takes an unicode string representing a munged header value |
| 162 | and decodes it as a (possibly non-ASCII) readable value.""" |
| 163 | parts = [] |
| 164 | for v, enc in _email_decode_header(header_str): |
| 165 | if isinstance(v, bytes): |
| 166 | parts.append(v.decode(enc or 'ascii')) |
| 167 | else: |
| 168 | parts.append(v) |
| 169 | return ' '.join(parts) |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 170 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 171 | def _parse_overview_fmt(lines): |
| 172 | """Parse a list of string representing the response to LIST OVERVIEW.FMT |
| 173 | and return a list of header/metadata names. |
| 174 | Raises NNTPDataError if the response is not compliant |
| 175 | (cf. RFC 3977, section 8.4).""" |
| 176 | fmt = [] |
| 177 | for line in lines: |
| 178 | if line[0] == ':': |
| 179 | # Metadata name (e.g. ":bytes") |
| 180 | name, _, suffix = line[1:].partition(':') |
| 181 | name = ':' + name |
| 182 | else: |
| 183 | # Header name (e.g. "Subject:" or "Xref:full") |
| 184 | name, _, suffix = line.partition(':') |
| 185 | name = name.lower() |
| 186 | name = _OVERVIEW_FMT_ALTERNATIVES.get(name, name) |
| 187 | # Should we do something with the suffix? |
| 188 | fmt.append(name) |
| 189 | defaults = _DEFAULT_OVERVIEW_FMT |
| 190 | if len(fmt) < len(defaults): |
| 191 | raise NNTPDataError("LIST OVERVIEW.FMT response too short") |
| 192 | if fmt[:len(defaults)] != defaults: |
| 193 | raise NNTPDataError("LIST OVERVIEW.FMT redefines default fields") |
| 194 | return fmt |
| 195 | |
| 196 | def _parse_overview(lines, fmt, data_process_func=None): |
| 197 | """Parse the response to a OVER or XOVER command according to the |
| 198 | overview format `fmt`.""" |
| 199 | n_defaults = len(_DEFAULT_OVERVIEW_FMT) |
| 200 | overview = [] |
| 201 | for line in lines: |
| 202 | fields = {} |
| 203 | article_number, *tokens = line.split('\t') |
| 204 | article_number = int(article_number) |
| 205 | for i, token in enumerate(tokens): |
| 206 | if i >= len(fmt): |
| 207 | # XXX should we raise an error? Some servers might not |
| 208 | # support LIST OVERVIEW.FMT and still return additional |
| 209 | # headers. |
| 210 | continue |
| 211 | field_name = fmt[i] |
| 212 | is_metadata = field_name.startswith(':') |
| 213 | if i >= n_defaults and not is_metadata: |
| 214 | # Non-default header names are included in full in the response |
Antoine Pitrou | 4103bc0 | 2010-11-03 18:18:43 +0000 | [diff] [blame] | 215 | # (unless the field is totally empty) |
| 216 | h = field_name + ": " |
| 217 | if token and token[:len(h)].lower() != h: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 218 | raise NNTPDataError("OVER/XOVER response doesn't include " |
| 219 | "names of additional headers") |
Antoine Pitrou | 4103bc0 | 2010-11-03 18:18:43 +0000 | [diff] [blame] | 220 | token = token[len(h):] if token else None |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 221 | fields[fmt[i]] = token |
| 222 | overview.append((article_number, fields)) |
| 223 | return overview |
| 224 | |
| 225 | def _parse_datetime(date_str, time_str=None): |
| 226 | """Parse a pair of (date, time) strings, and return a datetime object. |
| 227 | If only the date is given, it is assumed to be date and time |
| 228 | concatenated together (e.g. response to the DATE command). |
| 229 | """ |
| 230 | if time_str is None: |
| 231 | time_str = date_str[-6:] |
| 232 | date_str = date_str[:-6] |
| 233 | hours = int(time_str[:2]) |
| 234 | minutes = int(time_str[2:4]) |
| 235 | seconds = int(time_str[4:]) |
| 236 | year = int(date_str[:-4]) |
| 237 | month = int(date_str[-4:-2]) |
| 238 | day = int(date_str[-2:]) |
| 239 | # RFC 3977 doesn't say how to interpret 2-char years. Assume that |
| 240 | # there are no dates before 1970 on Usenet. |
| 241 | if year < 70: |
| 242 | year += 2000 |
| 243 | elif year < 100: |
| 244 | year += 1900 |
| 245 | return datetime.datetime(year, month, day, hours, minutes, seconds) |
| 246 | |
| 247 | def _unparse_datetime(dt, legacy=False): |
| 248 | """Format a date or datetime object as a pair of (date, time) strings |
| 249 | in the format required by the NEWNEWS and NEWGROUPS commands. If a |
| 250 | date object is passed, the time is assumed to be midnight (00h00). |
| 251 | |
| 252 | The returned representation depends on the legacy flag: |
| 253 | * if legacy is False (the default): |
| 254 | date has the YYYYMMDD format and time the HHMMSS format |
| 255 | * if legacy is True: |
| 256 | date has the YYMMDD format and time the HHMMSS format. |
| 257 | RFC 3977 compliant servers should understand both formats; therefore, |
| 258 | legacy is only needed when talking to old servers. |
| 259 | """ |
| 260 | if not isinstance(dt, datetime.datetime): |
| 261 | time_str = "000000" |
| 262 | else: |
| 263 | time_str = "{0.hour:02d}{0.minute:02d}{0.second:02d}".format(dt) |
| 264 | y = dt.year |
| 265 | if legacy: |
| 266 | y = y % 100 |
| 267 | date_str = "{0:02d}{1.month:02d}{1.day:02d}".format(y, dt) |
| 268 | else: |
| 269 | date_str = "{0:04d}{1.month:02d}{1.day:02d}".format(y, dt) |
| 270 | return date_str, time_str |
| 271 | |
| 272 | |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 273 | if _have_ssl: |
| 274 | |
| 275 | def _encrypt_on(sock, context): |
| 276 | """Wrap a socket in SSL/TLS. Arguments: |
| 277 | - sock: Socket to wrap |
| 278 | - context: SSL context to use for the encrypted connection |
| 279 | Returns: |
| 280 | - sock: New, encrypted socket. |
| 281 | """ |
| 282 | # Generate a default SSL context if none was passed. |
| 283 | if context is None: |
| 284 | context = ssl.SSLContext(ssl.PROTOCOL_SSLv23) |
| 285 | # SSLv2 considered harmful. |
| 286 | context.options |= ssl.OP_NO_SSLv2 |
| 287 | return context.wrap_socket(sock) |
| 288 | |
| 289 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 290 | # The classes themselves |
| 291 | class _NNTPBase: |
| 292 | # UTF-8 is the character set for all NNTP commands and responses: they |
| 293 | # are automatically encoded (when sending) and decoded (and receiving) |
| 294 | # by this class. |
| 295 | # However, some multi-line data blocks can contain arbitrary bytes (for |
| 296 | # example, latin-1 or utf-16 data in the body of a message). Commands |
| 297 | # taking (POST, IHAVE) or returning (HEAD, BODY, ARTICLE) raw message |
| 298 | # data will therefore only accept and produce bytes objects. |
| 299 | # Furthermore, since there could be non-compliant servers out there, |
| 300 | # we use 'surrogateescape' as the error handler for fault tolerance |
| 301 | # and easy round-tripping. This could be useful for some applications |
| 302 | # (e.g. NNTP gateways). |
| 303 | |
| 304 | encoding = 'utf-8' |
| 305 | errors = 'surrogateescape' |
| 306 | |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 307 | def __init__(self, file, host, |
| 308 | readermode=None, timeout=_GLOBAL_DEFAULT_TIMEOUT): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 309 | """Initialize an instance. Arguments: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 310 | - file: file-like object (open for read/write in binary mode) |
Antoine Pitrou | 859c4ef | 2010-11-09 18:58:42 +0000 | [diff] [blame] | 311 | - host: hostname of the server |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 312 | - readermode: if true, send 'mode reader' command after |
| 313 | connecting. |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 314 | - timeout: timeout (in seconds) used for socket connections |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 315 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 316 | readermode is sometimes necessary if you are connecting to an |
| 317 | NNTP server on the local machine and intend to call |
| 318 | reader-specific comamnds, such as `group'. If you get |
| 319 | unexpected NNTPPermanentErrors, you might need to set |
| 320 | readermode. |
| 321 | """ |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 322 | self.host = host |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 323 | self.file = file |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 324 | self.debugging = 0 |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 325 | self.welcome = self._getresp() |
Tim Peters | dfb673b | 2001-01-16 07:12:46 +0000 | [diff] [blame] | 326 | |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 327 | # 'MODE READER' is sometimes necessary to enable 'reader' mode. |
| 328 | # However, the order in which 'MODE READER' and 'AUTHINFO' need to |
| 329 | # arrive differs between some NNTP servers. If _setreadermode() fails |
| 330 | # with an authorization failed error, it will set this to True; |
| 331 | # the login() routine will interpret that as a request to try again |
| 332 | # after performing its normal function. |
| 333 | self.readermode_afterauth = False |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 334 | if readermode: |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 335 | self._setreadermode() |
Tim Peters | dfb673b | 2001-01-16 07:12:46 +0000 | [diff] [blame] | 336 | |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 337 | # RFC 4642 2.2.2: Both the client and the server MUST know if there is |
| 338 | # a TLS session active. A client MUST NOT attempt to start a TLS |
| 339 | # session if a TLS session is already active. |
| 340 | self.tls_on = False |
| 341 | |
| 342 | # Inquire about capabilities (RFC 3977). |
| 343 | self._caps = None |
| 344 | self.getcapabilities() |
| 345 | |
| 346 | # Log in and encryption setup order is left to subclasses. |
| 347 | self.authenticated = False |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 348 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 349 | def getwelcome(self): |
| 350 | """Get the welcome message from the server |
| 351 | (this is read and squirreled away by __init__()). |
| 352 | If the response code is 200, posting is allowed; |
| 353 | if it 201, posting is not allowed.""" |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 354 | |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 355 | if self.debugging: print('*welcome*', repr(self.welcome)) |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 356 | return self.welcome |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 357 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 358 | def getcapabilities(self): |
| 359 | """Get the server capabilities, as read by __init__(). |
| 360 | If the CAPABILITIES command is not supported, an empty dict is |
| 361 | returned.""" |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 362 | if self._caps is None: |
| 363 | self.nntp_version = 1 |
| 364 | self.nntp_implementation = None |
| 365 | try: |
| 366 | resp, caps = self.capabilities() |
| 367 | except NNTPPermanentError: |
| 368 | # Server doesn't support capabilities |
| 369 | self._caps = {} |
| 370 | else: |
| 371 | self._caps = caps |
| 372 | if 'VERSION' in caps: |
| 373 | # The server can advertise several supported versions, |
| 374 | # choose the highest. |
| 375 | self.nntp_version = max(map(int, caps['VERSION'])) |
| 376 | if 'IMPLEMENTATION' in caps: |
| 377 | self.nntp_implementation = ' '.join(caps['IMPLEMENTATION']) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 378 | return self._caps |
| 379 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 380 | def set_debuglevel(self, level): |
| 381 | """Set the debugging level. Argument 'level' means: |
| 382 | 0: no debugging output (default) |
| 383 | 1: print commands and responses but not body text etc. |
| 384 | 2: also print raw lines read and sent before stripping CR/LF""" |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 385 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 386 | self.debugging = level |
| 387 | debug = set_debuglevel |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 388 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 389 | def _putline(self, line): |
| 390 | """Internal: send one line to the server, appending CRLF. |
| 391 | The `line` must be a bytes-like object.""" |
| 392 | line = line + _CRLF |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 393 | if self.debugging > 1: print('*put*', repr(line)) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 394 | self.file.write(line) |
| 395 | self.file.flush() |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 396 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 397 | def _putcmd(self, line): |
| 398 | """Internal: send one command to the server (through _putline()). |
| 399 | The `line` must be an unicode string.""" |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 400 | if self.debugging: print('*cmd*', repr(line)) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 401 | line = line.encode(self.encoding, self.errors) |
| 402 | self._putline(line) |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 403 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 404 | def _getline(self, strip_crlf=True): |
| 405 | """Internal: return one line from the server, stripping _CRLF. |
| 406 | Raise EOFError if the connection is closed. |
| 407 | Returns a bytes object.""" |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 408 | line = self.file.readline() |
| 409 | if self.debugging > 1: |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 410 | print('*get*', repr(line)) |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 411 | if not line: raise EOFError |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 412 | if strip_crlf: |
| 413 | if line[-2:] == _CRLF: |
| 414 | line = line[:-2] |
| 415 | elif line[-1:] in _CRLF: |
| 416 | line = line[:-1] |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 417 | return line |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 418 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 419 | def _getresp(self): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 420 | """Internal: get a response from the server. |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 421 | Raise various errors if the response indicates an error. |
| 422 | Returns an unicode string.""" |
| 423 | resp = self._getline() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 424 | if self.debugging: print('*resp*', repr(resp)) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 425 | resp = resp.decode(self.encoding, self.errors) |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 426 | c = resp[:1] |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 427 | if c == '4': |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 428 | raise NNTPTemporaryError(resp) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 429 | if c == '5': |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 430 | raise NNTPPermanentError(resp) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 431 | if c not in '123': |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 432 | raise NNTPProtocolError(resp) |
| 433 | return resp |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 434 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 435 | def _getlongresp(self, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 436 | """Internal: get a response plus following text from the server. |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 437 | Raise various errors if the response indicates an error. |
| 438 | |
| 439 | Returns a (response, lines) tuple where `response` is an unicode |
| 440 | string and `lines` is a list of bytes objects. |
| 441 | If `file` is a file-like object, it must be open in binary mode. |
| 442 | """ |
Guido van Rossum | d1d584f | 2001-10-01 13:46:55 +0000 | [diff] [blame] | 443 | |
| 444 | openedFile = None |
| 445 | try: |
| 446 | # If a string was passed then open a file with that name |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 447 | if isinstance(file, (str, bytes)): |
| 448 | openedFile = file = open(file, "wb") |
Guido van Rossum | d1d584f | 2001-10-01 13:46:55 +0000 | [diff] [blame] | 449 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 450 | resp = self._getresp() |
| 451 | if resp[:3] not in _LONGRESP: |
Guido van Rossum | d1d584f | 2001-10-01 13:46:55 +0000 | [diff] [blame] | 452 | raise NNTPReplyError(resp) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 453 | |
| 454 | lines = [] |
| 455 | if file is not None: |
| 456 | # XXX lines = None instead? |
| 457 | terminators = (b'.' + _CRLF, b'.\n') |
| 458 | while 1: |
| 459 | line = self._getline(False) |
| 460 | if line in terminators: |
| 461 | break |
| 462 | if line.startswith(b'..'): |
| 463 | line = line[1:] |
| 464 | file.write(line) |
| 465 | else: |
| 466 | terminator = b'.' |
| 467 | while 1: |
| 468 | line = self._getline() |
| 469 | if line == terminator: |
| 470 | break |
| 471 | if line.startswith(b'..'): |
| 472 | line = line[1:] |
| 473 | lines.append(line) |
Guido van Rossum | d1d584f | 2001-10-01 13:46:55 +0000 | [diff] [blame] | 474 | finally: |
| 475 | # If this method created the file, then it must close it |
| 476 | if openedFile: |
| 477 | openedFile.close() |
| 478 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 479 | return resp, lines |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 480 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 481 | def _shortcmd(self, line): |
| 482 | """Internal: send a command and get the response. |
| 483 | Same return value as _getresp().""" |
| 484 | self._putcmd(line) |
| 485 | return self._getresp() |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 486 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 487 | def _longcmd(self, line, file=None): |
| 488 | """Internal: send a command and get the response plus following text. |
| 489 | Same return value as _getlongresp().""" |
| 490 | self._putcmd(line) |
| 491 | return self._getlongresp(file) |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 492 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 493 | def _longcmdstring(self, line, file=None): |
| 494 | """Internal: send a command and get the response plus following text. |
| 495 | Same as _longcmd() and _getlongresp(), except that the returned `lines` |
| 496 | are unicode strings rather than bytes objects. |
| 497 | """ |
| 498 | self._putcmd(line) |
| 499 | resp, list = self._getlongresp(file) |
| 500 | return resp, [line.decode(self.encoding, self.errors) |
| 501 | for line in list] |
| 502 | |
| 503 | def _getoverviewfmt(self): |
| 504 | """Internal: get the overview format. Queries the server if not |
| 505 | already done, else returns the cached value.""" |
| 506 | try: |
| 507 | return self._cachedoverviewfmt |
| 508 | except AttributeError: |
| 509 | pass |
| 510 | try: |
| 511 | resp, lines = self._longcmdstring("LIST OVERVIEW.FMT") |
| 512 | except NNTPPermanentError: |
| 513 | # Not supported by server? |
| 514 | fmt = _DEFAULT_OVERVIEW_FMT[:] |
| 515 | else: |
| 516 | fmt = _parse_overview_fmt(lines) |
| 517 | self._cachedoverviewfmt = fmt |
| 518 | return fmt |
| 519 | |
| 520 | def _grouplist(self, lines): |
| 521 | # Parse lines into "group last first flag" |
| 522 | return [GroupInfo(*line.split()) for line in lines] |
| 523 | |
| 524 | def capabilities(self): |
| 525 | """Process a CAPABILITIES command. Not supported by all servers. |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 526 | Return: |
| 527 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 528 | - caps: a dictionary mapping capability names to lists of tokens |
| 529 | (for example {'VERSION': ['2'], 'OVER': [], LIST: ['ACTIVE', 'HEADERS'] }) |
| 530 | """ |
| 531 | caps = {} |
| 532 | resp, lines = self._longcmdstring("CAPABILITIES") |
| 533 | for line in lines: |
| 534 | name, *tokens = line.split() |
| 535 | caps[name] = tokens |
| 536 | return resp, caps |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 537 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 538 | def newgroups(self, date, *, file=None): |
| 539 | """Process a NEWGROUPS command. Arguments: |
| 540 | - date: a date or datetime object |
| 541 | Return: |
| 542 | - resp: server response if successful |
| 543 | - list: list of newsgroup names |
| 544 | """ |
| 545 | if not isinstance(date, (datetime.date, datetime.date)): |
| 546 | raise TypeError( |
| 547 | "the date parameter must be a date or datetime object, " |
| 548 | "not '{:40}'".format(date.__class__.__name__)) |
| 549 | date_str, time_str = _unparse_datetime(date, self.nntp_version < 2) |
| 550 | cmd = 'NEWGROUPS {0} {1}'.format(date_str, time_str) |
| 551 | resp, lines = self._longcmdstring(cmd, file) |
| 552 | return resp, self._grouplist(lines) |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 553 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 554 | def newnews(self, group, date, *, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 555 | """Process a NEWNEWS command. Arguments: |
| 556 | - group: group name or '*' |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 557 | - date: a date or datetime object |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 558 | Return: |
| 559 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 560 | - list: list of message ids |
| 561 | """ |
| 562 | if not isinstance(date, (datetime.date, datetime.date)): |
| 563 | raise TypeError( |
| 564 | "the date parameter must be a date or datetime object, " |
| 565 | "not '{:40}'".format(date.__class__.__name__)) |
| 566 | date_str, time_str = _unparse_datetime(date, self.nntp_version < 2) |
| 567 | cmd = 'NEWNEWS {0} {1} {2}'.format(group, date_str, time_str) |
| 568 | return self._longcmdstring(cmd, file) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 569 | |
Antoine Pitrou | 08eeada | 2010-11-04 21:36:15 +0000 | [diff] [blame] | 570 | def list(self, group_pattern=None, *, file=None): |
| 571 | """Process a LIST or LIST ACTIVE command. Arguments: |
| 572 | - group_pattern: a pattern indicating which groups to query |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 573 | - file: Filename string or file object to store the result in |
| 574 | Returns: |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 575 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 576 | - list: list of (group, last, first, flag) (strings) |
| 577 | """ |
Antoine Pitrou | 08eeada | 2010-11-04 21:36:15 +0000 | [diff] [blame] | 578 | if group_pattern is not None: |
| 579 | command = 'LIST ACTIVE ' + group_pattern |
| 580 | else: |
| 581 | command = 'LIST' |
| 582 | resp, lines = self._longcmdstring(command, file) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 583 | return resp, self._grouplist(lines) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 584 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 585 | def _getdescriptions(self, group_pattern, return_all): |
| 586 | line_pat = re.compile('^(?P<group>[^ \t]+)[ \t]+(.*)$') |
| 587 | # Try the more std (acc. to RFC2980) LIST NEWSGROUPS first |
| 588 | resp, lines = self._longcmdstring('LIST NEWSGROUPS ' + group_pattern) |
| 589 | if not resp.startswith('215'): |
| 590 | # Now the deprecated XGTITLE. This either raises an error |
| 591 | # or succeeds with the same output structure as LIST |
| 592 | # NEWSGROUPS. |
| 593 | resp, lines = self._longcmdstring('XGTITLE ' + group_pattern) |
| 594 | groups = {} |
| 595 | for raw_line in lines: |
| 596 | match = line_pat.search(raw_line.strip()) |
| 597 | if match: |
| 598 | name, desc = match.group(1, 2) |
| 599 | if not return_all: |
| 600 | return desc |
| 601 | groups[name] = desc |
| 602 | if return_all: |
| 603 | return resp, groups |
| 604 | else: |
| 605 | # Nothing found |
| 606 | return '' |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 607 | |
Martin v. Löwis | cc0f932 | 2004-07-26 12:40:50 +0000 | [diff] [blame] | 608 | def description(self, group): |
Martin v. Löwis | cc0f932 | 2004-07-26 12:40:50 +0000 | [diff] [blame] | 609 | """Get a description for a single group. If more than one |
| 610 | group matches ('group' is a pattern), return the first. If no |
| 611 | group matches, return an empty string. |
| 612 | |
| 613 | This elides the response code from the server, since it can |
| 614 | only be '215' or '285' (for xgtitle) anyway. If the response |
| 615 | code is needed, use the 'descriptions' method. |
| 616 | |
| 617 | NOTE: This neither checks for a wildcard in 'group' nor does |
| 618 | it check whether the group actually exists.""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 619 | return self._getdescriptions(group, False) |
Martin v. Löwis | cc0f932 | 2004-07-26 12:40:50 +0000 | [diff] [blame] | 620 | |
| 621 | def descriptions(self, group_pattern): |
| 622 | """Get descriptions for a range of groups.""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 623 | return self._getdescriptions(group_pattern, True) |
Martin v. Löwis | cc0f932 | 2004-07-26 12:40:50 +0000 | [diff] [blame] | 624 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 625 | def group(self, name): |
| 626 | """Process a GROUP command. Argument: |
| 627 | - group: the group name |
| 628 | Returns: |
| 629 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 630 | - count: number of articles |
| 631 | - first: first article number |
| 632 | - last: last article number |
| 633 | - name: the group name |
| 634 | """ |
| 635 | resp = self._shortcmd('GROUP ' + name) |
| 636 | if not resp.startswith('211'): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 637 | raise NNTPReplyError(resp) |
Eric S. Raymond | b9c24fb | 2001-02-09 07:02:17 +0000 | [diff] [blame] | 638 | words = resp.split() |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 639 | count = first = last = 0 |
| 640 | n = len(words) |
| 641 | if n > 1: |
| 642 | count = words[1] |
| 643 | if n > 2: |
| 644 | first = words[2] |
| 645 | if n > 3: |
| 646 | last = words[3] |
| 647 | if n > 4: |
Eric S. Raymond | b9c24fb | 2001-02-09 07:02:17 +0000 | [diff] [blame] | 648 | name = words[4].lower() |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 649 | return resp, int(count), int(first), int(last), name |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 650 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 651 | def help(self, *, file=None): |
| 652 | """Process a HELP command. Argument: |
| 653 | - file: Filename string or file object to store the result in |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 654 | Returns: |
| 655 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 656 | - list: list of strings returned by the server in response to the |
| 657 | HELP command |
| 658 | """ |
| 659 | return self._longcmdstring('HELP', file) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 660 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 661 | def _statparse(self, resp): |
| 662 | """Internal: parse the response line of a STAT, NEXT, LAST, |
| 663 | ARTICLE, HEAD or BODY command.""" |
| 664 | if not resp.startswith('22'): |
| 665 | raise NNTPReplyError(resp) |
| 666 | words = resp.split() |
| 667 | art_num = int(words[1]) |
| 668 | message_id = words[2] |
| 669 | return resp, art_num, message_id |
| 670 | |
| 671 | def _statcmd(self, line): |
| 672 | """Internal: process a STAT, NEXT or LAST command.""" |
| 673 | resp = self._shortcmd(line) |
| 674 | return self._statparse(resp) |
| 675 | |
| 676 | def stat(self, message_spec=None): |
| 677 | """Process a STAT command. Argument: |
| 678 | - message_spec: article number or message id (if not specified, |
| 679 | the current article is selected) |
| 680 | Returns: |
| 681 | - resp: server response if successful |
| 682 | - art_num: the article number |
| 683 | - message_id: the message id |
| 684 | """ |
| 685 | if message_spec: |
| 686 | return self._statcmd('STAT {0}'.format(message_spec)) |
| 687 | else: |
| 688 | return self._statcmd('STAT') |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 689 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 690 | def next(self): |
| 691 | """Process a NEXT command. No arguments. Return as for STAT.""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 692 | return self._statcmd('NEXT') |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 693 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 694 | def last(self): |
| 695 | """Process a LAST command. No arguments. Return as for STAT.""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 696 | return self._statcmd('LAST') |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 697 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 698 | def _artcmd(self, line, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 699 | """Internal: process a HEAD, BODY or ARTICLE command.""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 700 | resp, lines = self._longcmd(line, file) |
| 701 | resp, art_num, message_id = self._statparse(resp) |
| 702 | return resp, ArticleInfo(art_num, message_id, lines) |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 703 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 704 | def head(self, message_spec=None, *, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 705 | """Process a HEAD command. Argument: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 706 | - message_spec: article number or message id |
| 707 | - file: filename string or file object to store the headers in |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 708 | Returns: |
| 709 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 710 | - ArticleInfo: (article number, message id, list of header lines) |
| 711 | """ |
| 712 | if message_spec is not None: |
| 713 | cmd = 'HEAD {0}'.format(message_spec) |
| 714 | else: |
| 715 | cmd = 'HEAD' |
| 716 | return self._artcmd(cmd, file) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 717 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 718 | def body(self, message_spec=None, *, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 719 | """Process a BODY command. Argument: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 720 | - message_spec: article number or message id |
| 721 | - file: filename string or file object to store the body in |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 722 | Returns: |
| 723 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 724 | - ArticleInfo: (article number, message id, list of body lines) |
| 725 | """ |
| 726 | if message_spec is not None: |
| 727 | cmd = 'BODY {0}'.format(message_spec) |
| 728 | else: |
| 729 | cmd = 'BODY' |
| 730 | return self._artcmd(cmd, file) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 731 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 732 | def article(self, message_spec=None, *, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 733 | """Process an ARTICLE command. Argument: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 734 | - message_spec: article number or message id |
| 735 | - file: filename string or file object to store the article in |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 736 | Returns: |
| 737 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 738 | - ArticleInfo: (article number, message id, list of article lines) |
| 739 | """ |
| 740 | if message_spec is not None: |
| 741 | cmd = 'ARTICLE {0}'.format(message_spec) |
| 742 | else: |
| 743 | cmd = 'ARTICLE' |
| 744 | return self._artcmd(cmd, file) |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 745 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 746 | def slave(self): |
| 747 | """Process a SLAVE command. Returns: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 748 | - resp: server response if successful |
| 749 | """ |
| 750 | return self._shortcmd('SLAVE') |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 751 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 752 | def xhdr(self, hdr, str, *, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 753 | """Process an XHDR command (optional server extension). Arguments: |
| 754 | - hdr: the header type (e.g. 'subject') |
| 755 | - str: an article nr, a message id, or a range nr1-nr2 |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 756 | - file: Filename string or file object to store the result in |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 757 | Returns: |
| 758 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 759 | - list: list of (nr, value) strings |
| 760 | """ |
| 761 | pat = re.compile('^([0-9]+) ?(.*)\n?') |
| 762 | resp, lines = self._longcmdstring('XHDR {0} {1}'.format(hdr, str), file) |
| 763 | def remove_number(line): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 764 | m = pat.match(line) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 765 | return m.group(1, 2) if m else line |
| 766 | return resp, [remove_number(line) for line in lines] |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 767 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 768 | def xover(self, start, end, *, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 769 | """Process an XOVER command (optional server extension) Arguments: |
| 770 | - start: start of range |
| 771 | - end: end of range |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 772 | - file: Filename string or file object to store the result in |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 773 | Returns: |
| 774 | - resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 775 | - list: list of dicts containing the response fields |
| 776 | """ |
| 777 | resp, lines = self._longcmdstring('XOVER {0}-{1}'.format(start, end), |
| 778 | file) |
| 779 | fmt = self._getoverviewfmt() |
| 780 | return resp, _parse_overview(lines, fmt) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 781 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 782 | def over(self, message_spec, *, file=None): |
| 783 | """Process an OVER command. If the command isn't supported, fall |
| 784 | back to XOVER. Arguments: |
| 785 | - message_spec: |
| 786 | - either a message id, indicating the article to fetch |
| 787 | information about |
| 788 | - or a (start, end) tuple, indicating a range of article numbers; |
| 789 | if end is None, information up to the newest message will be |
| 790 | retrieved |
| 791 | - or None, indicating the current article number must be used |
| 792 | - file: Filename string or file object to store the result in |
| 793 | Returns: |
| 794 | - resp: server response if successful |
| 795 | - list: list of dicts containing the response fields |
Guido van Rossum | 8421c4e | 1995-09-22 00:52:38 +0000 | [diff] [blame] | 796 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 797 | NOTE: the "message id" form isn't supported by XOVER |
| 798 | """ |
| 799 | cmd = 'OVER' if 'OVER' in self._caps else 'XOVER' |
| 800 | if isinstance(message_spec, (tuple, list)): |
| 801 | start, end = message_spec |
| 802 | cmd += ' {0}-{1}'.format(start, end or '') |
| 803 | elif message_spec is not None: |
| 804 | cmd = cmd + ' ' + message_spec |
| 805 | resp, lines = self._longcmdstring(cmd, file) |
| 806 | fmt = self._getoverviewfmt() |
| 807 | return resp, _parse_overview(lines, fmt) |
| 808 | |
| 809 | def xgtitle(self, group, *, file=None): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 810 | """Process an XGTITLE command (optional server extension) Arguments: |
| 811 | - group: group name wildcard (i.e. news.*) |
| 812 | Returns: |
| 813 | - resp: server response if successful |
| 814 | - list: list of (name,title) strings""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 815 | warnings.warn("The XGTITLE extension is not actively used, " |
| 816 | "use descriptions() instead", |
| 817 | PendingDeprecationWarning, 2) |
| 818 | line_pat = re.compile('^([^ \t]+)[ \t]+(.*)$') |
| 819 | resp, raw_lines = self._longcmdstring('XGTITLE ' + group, file) |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 820 | lines = [] |
| 821 | for raw_line in raw_lines: |
Eric S. Raymond | b9c24fb | 2001-02-09 07:02:17 +0000 | [diff] [blame] | 822 | match = line_pat.search(raw_line.strip()) |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 823 | if match: |
| 824 | lines.append(match.group(1, 2)) |
| 825 | return resp, lines |
Guido van Rossum | 8421c4e | 1995-09-22 00:52:38 +0000 | [diff] [blame] | 826 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 827 | def xpath(self, id): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 828 | """Process an XPATH command (optional server extension) Arguments: |
| 829 | - id: Message id of article |
| 830 | Returns: |
| 831 | resp: server response if successful |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 832 | path: directory path to article |
| 833 | """ |
| 834 | warnings.warn("The XPATH extension is not actively used", |
| 835 | PendingDeprecationWarning, 2) |
Guido van Rossum | 54f22ed | 2000-02-04 15:10:34 +0000 | [diff] [blame] | 836 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 837 | resp = self._shortcmd('XPATH {0}'.format(id)) |
| 838 | if not resp.startswith('223'): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 839 | raise NNTPReplyError(resp) |
| 840 | try: |
Eric S. Raymond | b9c24fb | 2001-02-09 07:02:17 +0000 | [diff] [blame] | 841 | [resp_num, path] = resp.split() |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 842 | except ValueError: |
| 843 | raise NNTPReplyError(resp) |
| 844 | else: |
| 845 | return resp, path |
Guido van Rossum | 8421c4e | 1995-09-22 00:52:38 +0000 | [diff] [blame] | 846 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 847 | def date(self): |
| 848 | """Process the DATE command. |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 849 | Returns: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 850 | - resp: server response if successful |
| 851 | - date: datetime object |
| 852 | """ |
| 853 | resp = self._shortcmd("DATE") |
| 854 | if not resp.startswith('111'): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 855 | raise NNTPReplyError(resp) |
Eric S. Raymond | b9c24fb | 2001-02-09 07:02:17 +0000 | [diff] [blame] | 856 | elem = resp.split() |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 857 | if len(elem) != 2: |
| 858 | raise NNTPDataError(resp) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 859 | date = elem[1] |
| 860 | if len(date) != 14: |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 861 | raise NNTPDataError(resp) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 862 | return resp, _parse_datetime(date, None) |
Guido van Rossum | 8421c4e | 1995-09-22 00:52:38 +0000 | [diff] [blame] | 863 | |
Christian Heimes | 933238a | 2008-11-05 19:44:21 +0000 | [diff] [blame] | 864 | def _post(self, command, f): |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 865 | resp = self._shortcmd(command) |
| 866 | # Raises a specific exception if posting is not allowed |
| 867 | if not resp.startswith('3'): |
Christian Heimes | 933238a | 2008-11-05 19:44:21 +0000 | [diff] [blame] | 868 | raise NNTPReplyError(resp) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 869 | if isinstance(f, (bytes, bytearray)): |
| 870 | f = f.splitlines() |
| 871 | # We don't use _putline() because: |
| 872 | # - we don't want additional CRLF if the file or iterable is already |
| 873 | # in the right format |
| 874 | # - we don't want a spurious flush() after each line is written |
| 875 | for line in f: |
| 876 | if not line.endswith(_CRLF): |
| 877 | line = line.rstrip(b"\r\n") + _CRLF |
Christian Heimes | 933238a | 2008-11-05 19:44:21 +0000 | [diff] [blame] | 878 | if line.startswith(b'.'): |
| 879 | line = b'.' + line |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 880 | self.file.write(line) |
| 881 | self.file.write(b".\r\n") |
| 882 | self.file.flush() |
| 883 | return self._getresp() |
Guido van Rossum | 8421c4e | 1995-09-22 00:52:38 +0000 | [diff] [blame] | 884 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 885 | def post(self, data): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 886 | """Process a POST command. Arguments: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 887 | - data: bytes object, iterable or file containing the article |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 888 | Returns: |
| 889 | - resp: server response if successful""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 890 | return self._post('POST', data) |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 891 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 892 | def ihave(self, message_id, data): |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 893 | """Process an IHAVE command. Arguments: |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 894 | - message_id: message-id of the article |
| 895 | - data: file containing the article |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 896 | Returns: |
| 897 | - resp: server response if successful |
| 898 | Note that if the server refuses the article an exception is raised.""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 899 | return self._post('IHAVE {0}'.format(message_id), data) |
| 900 | |
| 901 | def _close(self): |
| 902 | self.file.close() |
| 903 | del self.file |
Guido van Rossum | c629d34 | 1992-11-05 10:43:02 +0000 | [diff] [blame] | 904 | |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 905 | def quit(self): |
| 906 | """Process a QUIT command and close the socket. Returns: |
| 907 | - resp: server response if successful""" |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 908 | try: |
| 909 | resp = self._shortcmd('QUIT') |
| 910 | finally: |
| 911 | self._close() |
Tim Peters | 2344fae | 2001-01-15 00:50:52 +0000 | [diff] [blame] | 912 | return resp |
Guido van Rossum | e2ed9df | 1997-08-26 23:26:18 +0000 | [diff] [blame] | 913 | |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 914 | def login(self, user=None, password=None, usenetrc=True): |
| 915 | if self.authenticated: |
| 916 | raise ValueError("Already logged in.") |
| 917 | if not user and not usenetrc: |
| 918 | raise ValueError( |
| 919 | "At least one of `user` and `usenetrc` must be specified") |
| 920 | # If no login/password was specified but netrc was requested, |
| 921 | # try to get them from ~/.netrc |
| 922 | # Presume that if .netrc has an entry, NNRP authentication is required. |
| 923 | try: |
| 924 | if usenetrc and not user: |
| 925 | import netrc |
| 926 | credentials = netrc.netrc() |
| 927 | auth = credentials.authenticators(self.host) |
| 928 | if auth: |
| 929 | user = auth[0] |
| 930 | password = auth[2] |
| 931 | except IOError: |
| 932 | pass |
| 933 | # Perform NNTP authentication if needed. |
| 934 | if not user: |
| 935 | return |
| 936 | resp = self._shortcmd('authinfo user ' + user) |
| 937 | if resp.startswith('381'): |
| 938 | if not password: |
| 939 | raise NNTPReplyError(resp) |
| 940 | else: |
| 941 | resp = self._shortcmd('authinfo pass ' + password) |
| 942 | if not resp.startswith('281'): |
| 943 | raise NNTPPermanentError(resp) |
| 944 | # Attempt to send mode reader if it was requested after login. |
| 945 | if self.readermode_afterauth: |
| 946 | self._setreadermode() |
| 947 | |
| 948 | def _setreadermode(self): |
| 949 | try: |
| 950 | self.welcome = self._shortcmd('mode reader') |
| 951 | except NNTPPermanentError: |
| 952 | # Error 5xx, probably 'not implemented' |
| 953 | pass |
| 954 | except NNTPTemporaryError as e: |
| 955 | if e.response.startswith('480'): |
| 956 | # Need authorization before 'mode reader' |
| 957 | self.readermode_afterauth = True |
| 958 | else: |
| 959 | raise |
| 960 | |
| 961 | if _have_ssl: |
| 962 | def starttls(self, context=None): |
| 963 | """Process a STARTTLS command. Arguments: |
| 964 | - context: SSL context to use for the encrypted connection |
| 965 | """ |
| 966 | # Per RFC 4642, STARTTLS MUST NOT be sent after authentication or if |
| 967 | # a TLS session already exists. |
| 968 | if self.tls_on: |
| 969 | raise ValueError("TLS is already enabled.") |
| 970 | if self.authenticated: |
| 971 | raise ValueError("TLS cannot be started after authentication.") |
| 972 | resp = self._shortcmd('STARTTLS') |
| 973 | if resp.startswith('382'): |
| 974 | self.file.close() |
| 975 | self.sock = _encrypt_on(self.sock, context) |
| 976 | self.file = self.sock.makefile("rwb") |
| 977 | self.tls_on = True |
| 978 | # Capabilities may change after TLS starts up, so ask for them |
| 979 | # again. |
| 980 | self._caps = None |
| 981 | self.getcapabilities() |
| 982 | else: |
| 983 | raise NNTPError("TLS failed to start.") |
| 984 | |
Guido van Rossum | e2ed9df | 1997-08-26 23:26:18 +0000 | [diff] [blame] | 985 | |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 986 | class NNTP(_NNTPBase): |
| 987 | |
| 988 | def __init__(self, host, port=NNTP_PORT, user=None, password=None, |
Antoine Pitrou | 859c4ef | 2010-11-09 18:58:42 +0000 | [diff] [blame] | 989 | readermode=None, usenetrc=False, |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 990 | timeout=_GLOBAL_DEFAULT_TIMEOUT): |
| 991 | """Initialize an instance. Arguments: |
| 992 | - host: hostname to connect to |
| 993 | - port: port to connect to (default the standard NNTP port) |
| 994 | - user: username to authenticate with |
| 995 | - password: password to use with username |
| 996 | - readermode: if true, send 'mode reader' command after |
| 997 | connecting. |
| 998 | - usenetrc: allow loading username and password from ~/.netrc file |
| 999 | if not specified explicitly |
| 1000 | - timeout: timeout (in seconds) used for socket connections |
| 1001 | |
| 1002 | readermode is sometimes necessary if you are connecting to an |
| 1003 | NNTP server on the local machine and intend to call |
| 1004 | reader-specific comamnds, such as `group'. If you get |
| 1005 | unexpected NNTPPermanentErrors, you might need to set |
| 1006 | readermode. |
| 1007 | """ |
| 1008 | self.host = host |
| 1009 | self.port = port |
| 1010 | self.sock = socket.create_connection((host, port), timeout) |
| 1011 | file = self.sock.makefile("rwb") |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 1012 | _NNTPBase.__init__(self, file, host, |
| 1013 | readermode, timeout) |
| 1014 | if user or usenetrc: |
| 1015 | self.login(user, password, usenetrc) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 1016 | |
| 1017 | def _close(self): |
| 1018 | try: |
| 1019 | _NNTPBase._close(self) |
| 1020 | finally: |
| 1021 | self.sock.close() |
| 1022 | |
| 1023 | |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 1024 | if _have_ssl: |
| 1025 | class NNTP_SSL(_NNTPBase): |
| 1026 | |
| 1027 | def __init__(self, host, port=NNTP_SSL_PORT, |
| 1028 | user=None, password=None, ssl_context=None, |
Antoine Pitrou | 859c4ef | 2010-11-09 18:58:42 +0000 | [diff] [blame] | 1029 | readermode=None, usenetrc=False, |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 1030 | timeout=_GLOBAL_DEFAULT_TIMEOUT): |
| 1031 | """This works identically to NNTP.__init__, except for the change |
| 1032 | in default port and the `ssl_context` argument for SSL connections. |
| 1033 | """ |
| 1034 | self.sock = socket.create_connection((host, port), timeout) |
| 1035 | self.sock = _encrypt_on(self.sock, ssl_context) |
| 1036 | file = self.sock.makefile("rwb") |
| 1037 | _NNTPBase.__init__(self, file, host, |
| 1038 | readermode=readermode, timeout=timeout) |
| 1039 | if user or usenetrc: |
| 1040 | self.login(user, password, usenetrc) |
| 1041 | |
| 1042 | def _close(self): |
| 1043 | try: |
| 1044 | _NNTPBase._close(self) |
| 1045 | finally: |
| 1046 | self.sock.close() |
| 1047 | |
| 1048 | __all__.append("NNTP_SSL") |
| 1049 | |
| 1050 | |
Neal Norwitz | ef67956 | 2002-11-14 02:19:44 +0000 | [diff] [blame] | 1051 | # Test retrieval when run as a script. |
Eric S. Raymond | b2db587 | 2002-11-13 23:05:35 +0000 | [diff] [blame] | 1052 | if __name__ == '__main__': |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 1053 | import argparse |
| 1054 | from email.utils import parsedate |
| 1055 | |
| 1056 | parser = argparse.ArgumentParser(description="""\ |
| 1057 | nntplib built-in demo - display the latest articles in a newsgroup""") |
| 1058 | parser.add_argument('-g', '--group', default='gmane.comp.python.general', |
| 1059 | help='group to fetch messages from (default: %(default)s)') |
| 1060 | parser.add_argument('-s', '--server', default='news.gmane.org', |
| 1061 | help='NNTP server hostname (default: %(default)s)') |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 1062 | parser.add_argument('-p', '--port', default=-1, type=int, |
| 1063 | help='NNTP port number (default: %s / %s)' % (NNTP_PORT, NNTP_SSL_PORT)) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 1064 | parser.add_argument('-n', '--nb-articles', default=10, type=int, |
| 1065 | help='number of articles to fetch (default: %(default)s)') |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 1066 | parser.add_argument('-S', '--ssl', action='store_true', default=False, |
| 1067 | help='use NNTP over SSL') |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 1068 | args = parser.parse_args() |
| 1069 | |
Antoine Pitrou | 1cb121e | 2010-11-09 18:54:37 +0000 | [diff] [blame] | 1070 | port = args.port |
| 1071 | if not args.ssl: |
| 1072 | if port == -1: |
| 1073 | port = NNTP_PORT |
| 1074 | s = NNTP(host=args.server, port=port) |
| 1075 | else: |
| 1076 | if port == -1: |
| 1077 | port = NNTP_SSL_PORT |
| 1078 | s = NNTP_SSL(host=args.server, port=port) |
| 1079 | |
| 1080 | caps = s.getcapabilities() |
| 1081 | if 'STARTTLS' in caps: |
| 1082 | s.starttls() |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 1083 | resp, count, first, last, name = s.group(args.group) |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 1084 | print('Group', name, 'has', count, 'articles, range', first, 'to', last) |
Antoine Pitrou | 69ab951 | 2010-09-29 15:03:40 +0000 | [diff] [blame] | 1085 | |
| 1086 | def cut(s, lim): |
| 1087 | if len(s) > lim: |
| 1088 | s = s[:lim - 4] + "..." |
| 1089 | return s |
| 1090 | |
| 1091 | first = str(int(last) - args.nb_articles + 1) |
| 1092 | resp, overviews = s.xover(first, last) |
| 1093 | for artnum, over in overviews: |
| 1094 | author = decode_header(over['from']).split('<', 1)[0] |
| 1095 | subject = decode_header(over['subject']) |
| 1096 | lines = int(over[':lines']) |
| 1097 | print("{:7} {:20} {:42} ({})".format( |
| 1098 | artnum, cut(author, 20), cut(subject, 42), lines) |
| 1099 | ) |
| 1100 | |
| 1101 | s.quit() |