Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 1 | |
Guido van Rossum | b6775db | 1994-08-01 11:34:53 +0000 | [diff] [blame] | 2 | /* UNIX password file access module */ |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 3 | |
Barry Warsaw | 50c5cf1 | 1996-12-11 16:54:40 +0000 | [diff] [blame] | 4 | #include "Python.h" |
Serhiy Storchaka | 7cf5599 | 2013-02-10 21:56:49 +0200 | [diff] [blame] | 5 | #include "posixmodule.h" |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 6 | |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 7 | #include <pwd.h> |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 8 | |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 9 | #include "clinic/pwdmodule.c.h" |
| 10 | /*[clinic input] |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 11 | module pwd |
| 12 | [clinic start generated code]*/ |
Serhiy Storchaka | 1009bf1 | 2015-04-03 23:53:51 +0300 | [diff] [blame] | 13 | /*[clinic end generated code: output=da39a3ee5e6b4b0d input=60f628ef356b97b6]*/ |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 14 | |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 15 | static PyStructSequence_Field struct_pwd_type_fields[] = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 16 | {"pw_name", "user name"}, |
| 17 | {"pw_passwd", "password"}, |
| 18 | {"pw_uid", "user id"}, |
| 19 | {"pw_gid", "group id"}, |
| 20 | {"pw_gecos", "real name"}, |
| 21 | {"pw_dir", "home directory"}, |
| 22 | {"pw_shell", "shell program"}, |
| 23 | {0} |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 24 | }; |
| 25 | |
Martin v. Löwis | 14f8b4c | 2002-06-13 20:33:02 +0000 | [diff] [blame] | 26 | PyDoc_STRVAR(struct_passwd__doc__, |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 27 | "pwd.struct_passwd: Results from getpw*() routines.\n\n\ |
| 28 | This object may be accessed either as a tuple of\n\ |
| 29 | (pw_name,pw_passwd,pw_uid,pw_gid,pw_gecos,pw_dir,pw_shell)\n\ |
Martin v. Löwis | 14f8b4c | 2002-06-13 20:33:02 +0000 | [diff] [blame] | 30 | or via the object attributes as named in the above tuple."); |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 31 | |
| 32 | static PyStructSequence_Desc struct_pwd_type_desc = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 33 | "pwd.struct_passwd", |
| 34 | struct_passwd__doc__, |
| 35 | struct_pwd_type_fields, |
| 36 | 7, |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 37 | }; |
| 38 | |
Martin v. Löwis | 14f8b4c | 2002-06-13 20:33:02 +0000 | [diff] [blame] | 39 | PyDoc_STRVAR(pwd__doc__, |
| 40 | "This module provides access to the Unix password database.\n\ |
Guido van Rossum | 3e79c44 | 1998-03-03 22:03:26 +0000 | [diff] [blame] | 41 | It is available on all Unix versions.\n\ |
| 42 | \n\ |
| 43 | Password database entries are reported as 7-tuples containing the following\n\ |
| 44 | items from the password database (see `<pwd.h>'), in order:\n\ |
| 45 | pw_name, pw_passwd, pw_uid, pw_gid, pw_gecos, pw_dir, pw_shell.\n\ |
| 46 | The uid and gid items are integers, all others are strings. An\n\ |
Martin v. Löwis | 14f8b4c | 2002-06-13 20:33:02 +0000 | [diff] [blame] | 47 | exception is raised if the entry asked for cannot be found."); |
Guido van Rossum | 3e79c44 | 1998-03-03 22:03:26 +0000 | [diff] [blame] | 48 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 49 | |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 50 | typedef struct { |
| 51 | PyTypeObject *StructPwdType; |
| 52 | } pwdmodulestate; |
Hai Shi | f707d94 | 2020-03-16 21:15:01 +0800 | [diff] [blame] | 53 | |
| 54 | static inline pwdmodulestate* |
| 55 | get_pwd_state(PyObject *module) |
| 56 | { |
| 57 | void *state = PyModule_GetState(module); |
| 58 | assert(state != NULL); |
| 59 | return (pwdmodulestate *)state; |
| 60 | } |
| 61 | |
| 62 | #define modulestate_global get_pwd_state(PyState_FindModule(&pwdmodule)) |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 63 | |
| 64 | static struct PyModuleDef pwdmodule; |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 65 | |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 66 | #define DEFAULT_BUFFER_SIZE 1024 |
| 67 | |
Martin v. Löwis | 29275c9 | 2002-09-17 09:34:06 +0000 | [diff] [blame] | 68 | static void |
Neal Norwitz | eb8b3a6 | 2007-08-24 23:26:23 +0000 | [diff] [blame] | 69 | sets(PyObject *v, int i, const char* val) |
Martin v. Löwis | 29275c9 | 2002-09-17 09:34:06 +0000 | [diff] [blame] | 70 | { |
Neal Norwitz | 3d7a90d | 2007-10-27 05:40:06 +0000 | [diff] [blame] | 71 | if (val) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 72 | PyObject *o = PyUnicode_DecodeFSDefault(val); |
| 73 | PyStructSequence_SET_ITEM(v, i, o); |
Neal Norwitz | 3d7a90d | 2007-10-27 05:40:06 +0000 | [diff] [blame] | 74 | } |
Martin v. Löwis | 29275c9 | 2002-09-17 09:34:06 +0000 | [diff] [blame] | 75 | else { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 76 | PyStructSequence_SET_ITEM(v, i, Py_None); |
| 77 | Py_INCREF(Py_None); |
Martin v. Löwis | 29275c9 | 2002-09-17 09:34:06 +0000 | [diff] [blame] | 78 | } |
| 79 | } |
| 80 | |
Barry Warsaw | 50c5cf1 | 1996-12-11 16:54:40 +0000 | [diff] [blame] | 81 | static PyObject * |
Peter Schneider-Kamp | 39e0e5a | 2000-07-10 13:12:27 +0000 | [diff] [blame] | 82 | mkpwent(struct passwd *p) |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 83 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 84 | int setIndex = 0; |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 85 | PyObject *v = PyStructSequence_New(modulestate_global->StructPwdType); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 86 | if (v == NULL) |
| 87 | return NULL; |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 88 | |
Christian Heimes | 217cfd1 | 2007-12-02 14:31:20 +0000 | [diff] [blame] | 89 | #define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyLong_FromLong((long) val)) |
Martin v. Löwis | 29275c9 | 2002-09-17 09:34:06 +0000 | [diff] [blame] | 90 | #define SETS(i,val) sets(v, i, val) |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 91 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 92 | SETS(setIndex++, p->pw_name); |
Stefan Krah | 4500977 | 2016-04-26 11:43:21 +0200 | [diff] [blame] | 93 | #if defined(HAVE_STRUCT_PASSWD_PW_PASSWD) && !defined(__ANDROID__) |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 94 | SETS(setIndex++, p->pw_passwd); |
Stefan Krah | 267b639 | 2016-04-26 01:09:18 +0200 | [diff] [blame] | 95 | #else |
| 96 | SETS(setIndex++, ""); |
| 97 | #endif |
Serhiy Storchaka | 7cf5599 | 2013-02-10 21:56:49 +0200 | [diff] [blame] | 98 | PyStructSequence_SET_ITEM(v, setIndex++, _PyLong_FromUid(p->pw_uid)); |
| 99 | PyStructSequence_SET_ITEM(v, setIndex++, _PyLong_FromGid(p->pw_gid)); |
Stefan Krah | 267b639 | 2016-04-26 01:09:18 +0200 | [diff] [blame] | 100 | #if defined(HAVE_STRUCT_PASSWD_PW_GECOS) |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 101 | SETS(setIndex++, p->pw_gecos); |
Stefan Krah | 267b639 | 2016-04-26 01:09:18 +0200 | [diff] [blame] | 102 | #else |
| 103 | SETS(setIndex++, ""); |
| 104 | #endif |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 105 | SETS(setIndex++, p->pw_dir); |
| 106 | SETS(setIndex++, p->pw_shell); |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 107 | |
| 108 | #undef SETS |
| 109 | #undef SETI |
| 110 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 111 | if (PyErr_Occurred()) { |
| 112 | Py_XDECREF(v); |
| 113 | return NULL; |
| 114 | } |
Martin v. Löwis | dbd55b3 | 2002-03-01 10:38:44 +0000 | [diff] [blame] | 115 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 116 | return v; |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 117 | } |
| 118 | |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 119 | /*[clinic input] |
| 120 | pwd.getpwuid |
| 121 | |
| 122 | uidobj: object |
| 123 | / |
| 124 | |
| 125 | Return the password database entry for the given numeric user ID. |
| 126 | |
| 127 | See `help(pwd)` for more on password database entries. |
| 128 | [clinic start generated code]*/ |
Guido van Rossum | 3e79c44 | 1998-03-03 22:03:26 +0000 | [diff] [blame] | 129 | |
Barry Warsaw | 50c5cf1 | 1996-12-11 16:54:40 +0000 | [diff] [blame] | 130 | static PyObject * |
Serhiy Storchaka | 1a2b24f | 2016-07-07 17:35:15 +0300 | [diff] [blame] | 131 | pwd_getpwuid(PyObject *module, PyObject *uidobj) |
| 132 | /*[clinic end generated code: output=c4ee1d4d429b86c4 input=ae64d507a1c6d3e8]*/ |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 133 | { |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 134 | PyObject *retval = NULL; |
Serhiy Storchaka | 7cf5599 | 2013-02-10 21:56:49 +0200 | [diff] [blame] | 135 | uid_t uid; |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 136 | int nomem = 0; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 137 | struct passwd *p; |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 138 | char *buf = NULL, *buf2 = NULL; |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 139 | |
| 140 | if (!_Py_Uid_Converter(uidobj, &uid)) { |
Serhiy Storchaka | 55e2238 | 2013-02-11 20:32:47 +0200 | [diff] [blame] | 141 | if (PyErr_ExceptionMatches(PyExc_OverflowError)) |
| 142 | PyErr_Format(PyExc_KeyError, |
| 143 | "getpwuid(): uid not found"); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 144 | return NULL; |
Serhiy Storchaka | 55e2238 | 2013-02-11 20:32:47 +0200 | [diff] [blame] | 145 | } |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 146 | #ifdef HAVE_GETPWUID_R |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 147 | int status; |
| 148 | Py_ssize_t bufsize; |
Alexey Izbyshev | e359bc2 | 2018-11-04 18:44:16 +0300 | [diff] [blame] | 149 | /* Note: 'pwd' will be used via pointer 'p' on getpwuid_r success. */ |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 150 | struct passwd pwd; |
| 151 | |
Alexey Izbyshev | e359bc2 | 2018-11-04 18:44:16 +0300 | [diff] [blame] | 152 | Py_BEGIN_ALLOW_THREADS |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 153 | bufsize = sysconf(_SC_GETPW_R_SIZE_MAX); |
| 154 | if (bufsize == -1) { |
| 155 | bufsize = DEFAULT_BUFFER_SIZE; |
| 156 | } |
| 157 | |
| 158 | while(1) { |
| 159 | buf2 = PyMem_RawRealloc(buf, bufsize); |
| 160 | if (buf2 == NULL) { |
Zackery Spytz | 570e371 | 2018-11-05 12:26:40 -0700 | [diff] [blame] | 161 | p = NULL; |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 162 | nomem = 1; |
| 163 | break; |
| 164 | } |
| 165 | buf = buf2; |
| 166 | status = getpwuid_r(uid, &pwd, buf, bufsize, &p); |
| 167 | if (status != 0) { |
| 168 | p = NULL; |
| 169 | } |
| 170 | if (p != NULL || status != ERANGE) { |
| 171 | break; |
| 172 | } |
| 173 | if (bufsize > (PY_SSIZE_T_MAX >> 1)) { |
| 174 | nomem = 1; |
| 175 | break; |
| 176 | } |
| 177 | bufsize <<= 1; |
| 178 | } |
| 179 | |
| 180 | Py_END_ALLOW_THREADS |
| 181 | #else |
| 182 | p = getpwuid(uid); |
| 183 | #endif |
| 184 | if (p == NULL) { |
| 185 | PyMem_RawFree(buf); |
| 186 | if (nomem == 1) { |
| 187 | return PyErr_NoMemory(); |
| 188 | } |
Serhiy Storchaka | 7cf5599 | 2013-02-10 21:56:49 +0200 | [diff] [blame] | 189 | PyObject *uid_obj = _PyLong_FromUid(uid); |
| 190 | if (uid_obj == NULL) |
| 191 | return NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 192 | PyErr_Format(PyExc_KeyError, |
Serhiy Storchaka | 7cf5599 | 2013-02-10 21:56:49 +0200 | [diff] [blame] | 193 | "getpwuid(): uid not found: %S", uid_obj); |
| 194 | Py_DECREF(uid_obj); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 195 | return NULL; |
| 196 | } |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 197 | retval = mkpwent(p); |
| 198 | #ifdef HAVE_GETPWUID_R |
| 199 | PyMem_RawFree(buf); |
| 200 | #endif |
| 201 | return retval; |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 202 | } |
| 203 | |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 204 | /*[clinic input] |
| 205 | pwd.getpwnam |
| 206 | |
William Grzybowski | 2865848 | 2018-09-07 14:10:39 -0300 | [diff] [blame] | 207 | name: unicode |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 208 | / |
| 209 | |
| 210 | Return the password database entry for the given user name. |
| 211 | |
| 212 | See `help(pwd)` for more on password database entries. |
| 213 | [clinic start generated code]*/ |
Guido van Rossum | 3e79c44 | 1998-03-03 22:03:26 +0000 | [diff] [blame] | 214 | |
Barry Warsaw | 50c5cf1 | 1996-12-11 16:54:40 +0000 | [diff] [blame] | 215 | static PyObject * |
William Grzybowski | 2865848 | 2018-09-07 14:10:39 -0300 | [diff] [blame] | 216 | pwd_getpwnam_impl(PyObject *module, PyObject *name) |
| 217 | /*[clinic end generated code: output=359ce1ddeb7a824f input=a6aeb5e3447fb9e0]*/ |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 218 | { |
William Grzybowski | 2865848 | 2018-09-07 14:10:39 -0300 | [diff] [blame] | 219 | char *buf = NULL, *buf2 = NULL, *name_chars; |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 220 | int nomem = 0; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 221 | struct passwd *p; |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 222 | PyObject *bytes, *retval = NULL; |
Martin v. Löwis | b6a748b | 2009-05-29 15:23:17 +0000 | [diff] [blame] | 223 | |
William Grzybowski | 2865848 | 2018-09-07 14:10:39 -0300 | [diff] [blame] | 224 | if ((bytes = PyUnicode_EncodeFSDefault(name)) == NULL) |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 225 | return NULL; |
Serhiy Storchaka | f7eae0a | 2017-06-28 08:30:06 +0300 | [diff] [blame] | 226 | /* check for embedded null bytes */ |
William Grzybowski | 2865848 | 2018-09-07 14:10:39 -0300 | [diff] [blame] | 227 | if (PyBytes_AsStringAndSize(bytes, &name_chars, NULL) == -1) |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 228 | goto out; |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 229 | #ifdef HAVE_GETPWNAM_R |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 230 | int status; |
| 231 | Py_ssize_t bufsize; |
Alexey Izbyshev | e359bc2 | 2018-11-04 18:44:16 +0300 | [diff] [blame] | 232 | /* Note: 'pwd' will be used via pointer 'p' on getpwnam_r success. */ |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 233 | struct passwd pwd; |
| 234 | |
Alexey Izbyshev | e359bc2 | 2018-11-04 18:44:16 +0300 | [diff] [blame] | 235 | Py_BEGIN_ALLOW_THREADS |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 236 | bufsize = sysconf(_SC_GETPW_R_SIZE_MAX); |
| 237 | if (bufsize == -1) { |
| 238 | bufsize = DEFAULT_BUFFER_SIZE; |
| 239 | } |
| 240 | |
| 241 | while(1) { |
| 242 | buf2 = PyMem_RawRealloc(buf, bufsize); |
| 243 | if (buf2 == NULL) { |
Zackery Spytz | 570e371 | 2018-11-05 12:26:40 -0700 | [diff] [blame] | 244 | p = NULL; |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 245 | nomem = 1; |
| 246 | break; |
| 247 | } |
| 248 | buf = buf2; |
William Grzybowski | 2865848 | 2018-09-07 14:10:39 -0300 | [diff] [blame] | 249 | status = getpwnam_r(name_chars, &pwd, buf, bufsize, &p); |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 250 | if (status != 0) { |
| 251 | p = NULL; |
| 252 | } |
| 253 | if (p != NULL || status != ERANGE) { |
| 254 | break; |
| 255 | } |
| 256 | if (bufsize > (PY_SSIZE_T_MAX >> 1)) { |
| 257 | nomem = 1; |
| 258 | break; |
| 259 | } |
| 260 | bufsize <<= 1; |
| 261 | } |
| 262 | |
| 263 | Py_END_ALLOW_THREADS |
| 264 | #else |
William Grzybowski | 2865848 | 2018-09-07 14:10:39 -0300 | [diff] [blame] | 265 | p = getpwnam(name_chars); |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 266 | #endif |
| 267 | if (p == NULL) { |
| 268 | if (nomem == 1) { |
| 269 | PyErr_NoMemory(); |
| 270 | } |
| 271 | else { |
| 272 | PyErr_Format(PyExc_KeyError, |
William Grzybowski | 34c7f0c | 2018-12-05 17:10:18 -0200 | [diff] [blame] | 273 | "getpwnam(): name not found: %R", name); |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 274 | } |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 275 | goto out; |
| 276 | } |
| 277 | retval = mkpwent(p); |
Martin v. Löwis | b6a748b | 2009-05-29 15:23:17 +0000 | [diff] [blame] | 278 | out: |
William Grzybowski | 23e65b2 | 2018-09-07 09:06:15 -0300 | [diff] [blame] | 279 | PyMem_RawFree(buf); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 280 | Py_DECREF(bytes); |
| 281 | return retval; |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 282 | } |
| 283 | |
Guido van Rossum | 1171ee6 | 1997-08-22 20:42:00 +0000 | [diff] [blame] | 284 | #ifdef HAVE_GETPWENT |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 285 | /*[clinic input] |
| 286 | pwd.getpwall |
| 287 | |
| 288 | Return a list of all available password database entries, in arbitrary order. |
| 289 | |
| 290 | See help(pwd) for more on password database entries. |
| 291 | [clinic start generated code]*/ |
Guido van Rossum | 3e79c44 | 1998-03-03 22:03:26 +0000 | [diff] [blame] | 292 | |
Barry Warsaw | 50c5cf1 | 1996-12-11 16:54:40 +0000 | [diff] [blame] | 293 | static PyObject * |
Serhiy Storchaka | 1a2b24f | 2016-07-07 17:35:15 +0300 | [diff] [blame] | 294 | pwd_getpwall_impl(PyObject *module) |
| 295 | /*[clinic end generated code: output=4853d2f5a0afac8a input=d7ecebfd90219b85]*/ |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 296 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 297 | PyObject *d; |
| 298 | struct passwd *p; |
| 299 | if ((d = PyList_New(0)) == NULL) |
| 300 | return NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 301 | setpwent(); |
| 302 | while ((p = getpwent()) != NULL) { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 303 | PyObject *v = mkpwent(p); |
| 304 | if (v == NULL || PyList_Append(d, v) != 0) { |
| 305 | Py_XDECREF(v); |
| 306 | Py_DECREF(d); |
| 307 | endpwent(); |
| 308 | return NULL; |
| 309 | } |
| 310 | Py_DECREF(v); |
| 311 | } |
| 312 | endpwent(); |
| 313 | return d; |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 314 | } |
Guido van Rossum | 1171ee6 | 1997-08-22 20:42:00 +0000 | [diff] [blame] | 315 | #endif |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 316 | |
Barry Warsaw | 50c5cf1 | 1996-12-11 16:54:40 +0000 | [diff] [blame] | 317 | static PyMethodDef pwd_methods[] = { |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 318 | PWD_GETPWUID_METHODDEF |
| 319 | PWD_GETPWNAM_METHODDEF |
Guido van Rossum | 1171ee6 | 1997-08-22 20:42:00 +0000 | [diff] [blame] | 320 | #ifdef HAVE_GETPWENT |
Brett Cannon | 3d25e16 | 2014-08-22 14:03:51 -0400 | [diff] [blame] | 321 | PWD_GETPWALL_METHODDEF |
Guido van Rossum | 1171ee6 | 1997-08-22 20:42:00 +0000 | [diff] [blame] | 322 | #endif |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 323 | {NULL, NULL} /* sentinel */ |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 324 | }; |
| 325 | |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 326 | static int pwdmodule_traverse(PyObject *m, visitproc visit, void *arg) { |
Hai Shi | f707d94 | 2020-03-16 21:15:01 +0800 | [diff] [blame] | 327 | Py_VISIT(get_pwd_state(m)->StructPwdType); |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 328 | return 0; |
| 329 | } |
| 330 | static int pwdmodule_clear(PyObject *m) { |
Hai Shi | f707d94 | 2020-03-16 21:15:01 +0800 | [diff] [blame] | 331 | Py_CLEAR(get_pwd_state(m)->StructPwdType); |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 332 | return 0; |
| 333 | } |
| 334 | static void pwdmodule_free(void *m) { |
| 335 | pwdmodule_clear((PyObject *)m); |
| 336 | } |
| 337 | |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 338 | static struct PyModuleDef pwdmodule = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 339 | PyModuleDef_HEAD_INIT, |
| 340 | "pwd", |
| 341 | pwd__doc__, |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 342 | sizeof(pwdmodulestate), |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 343 | pwd_methods, |
| 344 | NULL, |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 345 | pwdmodule_traverse, |
| 346 | pwdmodule_clear, |
| 347 | pwdmodule_free, |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 348 | }; |
| 349 | |
| 350 | |
Mark Hammond | fe51c6d | 2002-08-02 02:27:13 +0000 | [diff] [blame] | 351 | PyMODINIT_FUNC |
Martin v. Löwis | 1a21451 | 2008-06-11 05:26:20 +0000 | [diff] [blame] | 352 | PyInit_pwd(void) |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 353 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 354 | PyObject *m; |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 355 | if ((m = PyState_FindModule(&pwdmodule)) != NULL) { |
| 356 | Py_INCREF(m); |
| 357 | return m; |
| 358 | } |
| 359 | if ((m = PyModule_Create(&pwdmodule)) == NULL) |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 360 | return NULL; |
Fred Drake | 88c9344 | 2002-04-13 21:07:45 +0000 | [diff] [blame] | 361 | |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 362 | pwdmodulestate *state = PyModule_GetState(m); |
| 363 | state->StructPwdType = PyStructSequence_NewType(&struct_pwd_type_desc); |
| 364 | if (state->StructPwdType == NULL) { |
| 365 | return NULL; |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 366 | } |
Dino Viehland | b7f8e52 | 2019-09-10 13:59:43 +0100 | [diff] [blame] | 367 | Py_INCREF(state->StructPwdType); |
| 368 | PyModule_AddObject(m, "struct_passwd", (PyObject *) state->StructPwdType); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 369 | return m; |
Guido van Rossum | 864407d | 1991-04-10 19:48:25 +0000 | [diff] [blame] | 370 | } |