LCOV - code coverage report
Current view: top level - source3/smbd - pysmbd.c (source / functions) Hit Total Coverage
Test: coverage report for master 6248eab5 Lines: 314 532 59.0 %
Date: 2021-08-25 13:27:56 Functions: 16 18 88.9 %

          Line data    Source code
       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    Set NT and POSIX ACLs and other VFS operations from Python
       4             : 
       5             :    Copyrigyt (C) Andrew Bartlett 2012
       6             :    Copyright (C) Jeremy Allison 1994-2009.
       7             :    Copyright (C) Andreas Gruenbacher 2002.
       8             :    Copyright (C) Simo Sorce <idra@samba.org> 2009.
       9             :    Copyright (C) Simo Sorce 2002
      10             :    Copyright (C) Eric Lorimer 2002
      11             : 
      12             :    This program is free software; you can redistribute it and/or modify
      13             :    it under the terms of the GNU General Public License as published by
      14             :    the Free Software Foundation; either version 3 of the License, or
      15             :    (at your option) any later version.
      16             : 
      17             :    This program is distributed in the hope that it will be useful,
      18             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      19             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      20             :    GNU General Public License for more details.
      21             : 
      22             :    You should have received a copy of the GNU General Public License
      23             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      24             : */
      25             : 
      26             : #include <Python.h>
      27             : #include "includes.h"
      28             : #include "python/py3compat.h"
      29             : #include "python/modules.h"
      30             : #include "smbd/smbd.h"
      31             : #include "libcli/util/pyerrors.h"
      32             : #include "librpc/rpc/pyrpc_util.h"
      33             : #include <pytalloc.h>
      34             : #include "system/filesys.h"
      35             : #include "passdb.h"
      36             : #include "secrets.h"
      37             : #include "auth.h"
      38             : 
      39             : extern const struct generic_mapping file_generic_mapping;
      40             : 
      41             : #undef  DBGC_CLASS
      42             : #define DBGC_CLASS DBGC_ACLS
      43             : 
      44             : #ifdef O_DIRECTORY
      45             : #define DIRECTORY_FLAGS O_RDONLY|O_DIRECTORY
      46             : #else
      47             : /* POSIX allows us to open a directory with O_RDONLY. */
      48             : #define DIRECTORY_FLAGS O_RDONLY
      49             : #endif
      50             : 
      51             : 
      52        3691 : static connection_struct *get_conn_tos(
      53             :         const char *service,
      54             :         const struct auth_session_info *session_info)
      55             : {
      56        3691 :         struct conn_struct_tos *c = NULL;
      57        3691 :         int snum = -1;
      58             :         NTSTATUS status;
      59        3691 :         char *cwd = NULL;
      60        3691 :         struct smb_filename cwd_fname = {0};
      61             :         int ret;
      62             : 
      63        3691 :         if (!posix_locking_init(false)) {
      64           0 :                 PyErr_NoMemory();
      65           0 :                 return NULL;
      66             :         }
      67             : 
      68        3691 :         if (service) {
      69        2415 :                 snum = lp_servicenumber(service);
      70        2415 :                 if (snum == -1) {
      71           0 :                         PyErr_SetString(PyExc_RuntimeError, "unknown service");
      72           0 :                         return NULL;
      73             :                 }
      74             :         }
      75             : 
      76             :         /*
      77             :          * Make sure that session unix info is filled,
      78             :          * which is required by vfs operations.
      79             :          */
      80        3691 :         if (session_info->unix_info == NULL) {
      81           0 :                 PyErr_SetString(PyExc_RuntimeError,
      82             :                                 "Session unix info not initialized");
      83           0 :                 return NULL;
      84             :         }
      85        3691 :         if (session_info->unix_info->unix_name == NULL) {
      86           0 :                 PyErr_SetString(PyExc_RuntimeError,
      87             :                                 "Session unix info not available");
      88           0 :                 return NULL;
      89             :         }
      90             : 
      91        3691 :         status = create_conn_struct_tos(NULL,
      92             :                                         snum,
      93             :                                         "/",
      94             :                                         session_info,
      95             :                                         &c);
      96        3691 :         PyErr_NTSTATUS_IS_ERR_RAISE(status);
      97             : 
      98             :         /* Ignore read-only and share restrictions */
      99        3691 :         c->conn->read_only = false;
     100        3691 :         c->conn->share_access = SEC_RIGHTS_FILE_ALL;
     101             : 
     102             :         /* Provided by libreplace if not present. Always mallocs. */
     103        3691 :         cwd = get_current_dir_name();
     104        3691 :         if (cwd == NULL) {
     105           0 :                 PyErr_NoMemory();
     106           0 :                 return NULL;
     107             :         }
     108             : 
     109        3691 :         cwd_fname.base_name = cwd;
     110             :         /*
     111             :          * We need to call vfs_ChDir() to initialize
     112             :          * conn->cwd_fsp correctly. Change directory
     113             :          * to current directory (so no change for process).
     114             :          */
     115        3691 :         ret = vfs_ChDir(c->conn, &cwd_fname);
     116        3691 :         if (ret != 0) {
     117           0 :                 status = map_nt_error_from_unix(errno);
     118           0 :                 SAFE_FREE(cwd);
     119           0 :                 PyErr_NTSTATUS_IS_ERR_RAISE(status);
     120             :         }
     121             : 
     122        3691 :         SAFE_FREE(cwd);
     123             : 
     124        3691 :         return c->conn;
     125             : }
     126             : 
     127         183 : static int set_sys_acl_conn(const char *fname,
     128             :                                  SMB_ACL_TYPE_T acltype,
     129             :                                  SMB_ACL_T theacl, connection_struct *conn)
     130             : {
     131             :         int ret;
     132         183 :         struct smb_filename *smb_fname = NULL;
     133         183 :         TALLOC_CTX *frame = talloc_stackframe();
     134             :         NTSTATUS status;
     135             : 
     136         183 :         smb_fname = synthetic_smb_fname_split(frame,
     137             :                                         fname,
     138         183 :                                         lp_posix_pathnames());
     139         183 :         if (smb_fname == NULL) {
     140           0 :                 TALLOC_FREE(frame);
     141           0 :                 return -1;
     142             :         }
     143             : 
     144         183 :         ret = vfs_stat(conn, smb_fname);
     145         183 :         if (ret == -1) {
     146           0 :                 TALLOC_FREE(frame);
     147           0 :                 return -1;
     148             :         }
     149             : 
     150         183 :         status = openat_pathref_fsp(conn->cwd_fsp, smb_fname);
     151         183 :         if (!NT_STATUS_IS_OK(status)) {
     152           0 :                 TALLOC_FREE(frame);
     153           0 :                 errno = map_errno_from_nt_status(status);
     154           0 :                 return -1;
     155             :         }
     156             : 
     157         183 :         ret = SMB_VFS_SYS_ACL_SET_FD(smb_fname->fsp, acltype, theacl);
     158             : 
     159         183 :         TALLOC_FREE(frame);
     160         178 :         return ret;
     161             : }
     162             : 
     163             : 
     164        3544 : static NTSTATUS init_files_struct(TALLOC_CTX *mem_ctx,
     165             :                                   const char *fname,
     166             :                                   struct connection_struct *conn,
     167             :                                   int flags,
     168             :                                   struct files_struct **_fsp)
     169             : {
     170        3544 :         struct smb_filename *smb_fname = NULL;
     171             :         int fd;
     172             :         int ret;
     173             :         mode_t saved_umask;
     174             :         struct files_struct *fsp;
     175        3544 :         struct files_struct *fspcwd = NULL;
     176             :         NTSTATUS status;
     177             : 
     178        3544 :         fsp = talloc_zero(mem_ctx, struct files_struct);
     179        3544 :         if (fsp == NULL) {
     180           0 :                 return NT_STATUS_NO_MEMORY;
     181             :         }
     182        3544 :         fsp->fh = fd_handle_create(fsp);
     183        3544 :         if (fsp->fh == NULL) {
     184           0 :                 return NT_STATUS_NO_MEMORY;
     185             :         }
     186        3544 :         fsp->conn = conn;
     187             : 
     188        3544 :         smb_fname = synthetic_smb_fname_split(fsp,
     189             :                                               fname,
     190        3544 :                                               lp_posix_pathnames());
     191        3544 :         if (smb_fname == NULL) {
     192           0 :                 return NT_STATUS_NO_MEMORY;
     193             :         }
     194             : 
     195        3544 :         fsp->fsp_name = smb_fname;
     196             : 
     197        3544 :         status = vfs_at_fspcwd(fsp, conn, &fspcwd);
     198        3544 :         if (!NT_STATUS_IS_OK(status)) {
     199           0 :                 return status;
     200             :         }
     201             : 
     202             :         /*
     203             :          * we want total control over the permissions on created files,
     204             :          * so set our umask to 0 (this matters if flags contains O_CREAT)
     205             :          */
     206        3544 :         saved_umask = umask(0);
     207             : 
     208        3544 :         fd = SMB_VFS_OPENAT(conn,
     209             :                             fspcwd,
     210             :                             smb_fname,
     211             :                             fsp,
     212             :                             flags,
     213             :                             00644);
     214             : 
     215        3544 :         umask(saved_umask);
     216             : 
     217        3544 :         if (fd == -1) {
     218        1439 :                 int err = errno;
     219        1439 :                 if (err == ENOENT) {
     220           0 :                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
     221             :                 }
     222        1439 :                 return NT_STATUS_INVALID_PARAMETER;
     223             :         }
     224        2105 :         fsp_set_fd(fsp, fd);
     225             : 
     226        2105 :         ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
     227        2105 :         if (ret == -1) {
     228             :                 /* If we have an fd, this stat should succeed. */
     229           0 :                 DEBUG(0,("Error doing fstat on open file %s (%s)\n",
     230             :                          smb_fname_str_dbg(smb_fname),
     231             :                          strerror(errno) ));
     232           0 :                 return map_nt_error_from_unix(errno);
     233             :         }
     234             : 
     235        2105 :         fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
     236        2105 :         fsp->vuid = UID_FIELD_INVALID;
     237        2105 :         fsp->file_pid = 0;
     238        2105 :         fsp->fsp_flags.can_lock = true;
     239        2105 :         fsp->fsp_flags.can_read = true;
     240        2105 :         fsp->fsp_flags.can_write = true;
     241        2105 :         fsp->print_file = NULL;
     242        2105 :         fsp->fsp_flags.modified = false;
     243        2105 :         fsp->sent_oplock_break = NO_BREAK_SENT;
     244        2105 :         fsp->fsp_flags.is_directory = S_ISDIR(smb_fname->st.st_ex_mode);
     245             : 
     246        2105 :         *_fsp = fsp;
     247             : 
     248        2105 :         return NT_STATUS_OK;
     249             : }
     250             : 
     251        1895 : static NTSTATUS set_nt_acl_conn(const char *fname,
     252             :                                 uint32_t security_info_sent, const struct security_descriptor *sd,
     253             :                                 connection_struct *conn)
     254             : {
     255        1895 :         TALLOC_CTX *frame = talloc_stackframe();
     256        1895 :         struct files_struct *fsp = NULL;
     257        1895 :         NTSTATUS status = NT_STATUS_OK;
     258             : 
     259             :         /* first, try to open it as a file with flag O_RDWR */
     260        1895 :         status = init_files_struct(frame,
     261             :                                    fname,
     262             :                                    conn,
     263             :                                    O_RDWR,
     264             :                                    &fsp);
     265        1895 :         if (!NT_STATUS_IS_OK(status) && errno == EISDIR) {
     266             :                 /* if fail, try to open as dir */
     267        1427 :                 status = init_files_struct(frame,
     268             :                                            fname,
     269             :                                            conn,
     270             :                                            DIRECTORY_FLAGS,
     271             :                                            &fsp);
     272             :         }
     273             : 
     274        1895 :         if (!NT_STATUS_IS_OK(status)) {
     275           0 :                 DBG_ERR("init_files_struct failed: %s\n",
     276             :                         nt_errstr(status));
     277           0 :                 if (fsp != NULL) {
     278           0 :                         SMB_VFS_CLOSE(fsp);
     279             :                 }
     280           0 :                 TALLOC_FREE(frame);
     281           0 :                 return status;
     282             :         }
     283             : 
     284        1895 :         status = SMB_VFS_FSET_NT_ACL(fsp, security_info_sent, sd);
     285        1895 :         if (!NT_STATUS_IS_OK(status)) {
     286           0 :                 DEBUG(0,("set_nt_acl_no_snum: fset_nt_acl returned %s.\n", nt_errstr(status)));
     287             :         }
     288             : 
     289        1895 :         SMB_VFS_CLOSE(fsp);
     290             : 
     291        1895 :         TALLOC_FREE(frame);
     292        1895 :         return status;
     293             : }
     294             : 
     295         478 : static NTSTATUS get_nt_acl_conn(TALLOC_CTX *mem_ctx,
     296             :                                 const char *fname,
     297             :                                 connection_struct *conn,
     298             :                                 uint32_t security_info_wanted,
     299             :                                 struct security_descriptor **sd)
     300             : {
     301         478 :         TALLOC_CTX *frame = talloc_stackframe();
     302             :         NTSTATUS status;
     303             :         int ret;
     304         478 :         struct smb_filename *smb_fname =  NULL;
     305             : 
     306         478 :         smb_fname = synthetic_smb_fname_split(frame,
     307             :                                         fname,
     308         478 :                                         lp_posix_pathnames());
     309             : 
     310         478 :         if (smb_fname == NULL) {
     311           0 :                 TALLOC_FREE(frame);
     312           0 :                 return NT_STATUS_NO_MEMORY;
     313             :         }
     314             : 
     315         478 :         ret = vfs_stat(conn, smb_fname);
     316         478 :         if (ret == -1) {
     317           0 :                 TALLOC_FREE(frame);
     318           0 :                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
     319             :         }
     320             : 
     321         478 :         status = openat_pathref_fsp(conn->cwd_fsp, smb_fname);
     322         478 :         if (!NT_STATUS_IS_OK(status)) {
     323           0 :                 TALLOC_FREE(frame);
     324           0 :                 return status;
     325             :         }
     326             : 
     327         478 :         status = SMB_VFS_FGET_NT_ACL(smb_fname->fsp,
     328             :                                 security_info_wanted,
     329             :                                 mem_ctx,
     330             :                                 sd);
     331         478 :         if (!NT_STATUS_IS_OK(status)) {
     332           0 :                 DBG_ERR("fget_nt_acl_at returned %s.\n",
     333             :                         nt_errstr(status));
     334             :         }
     335             : 
     336         478 :         TALLOC_FREE(frame);
     337             : 
     338         478 :         return status;
     339             : }
     340             : 
     341         831 : static int set_acl_entry_perms(SMB_ACL_ENTRY_T entry, mode_t perm_mask)
     342             : {
     343         831 :         SMB_ACL_PERMSET_T perms = NULL;
     344             : 
     345         831 :         if (sys_acl_get_permset(entry, &perms) != 0) {
     346           0 :                 return -1;
     347             :         }
     348             : 
     349         831 :         if (sys_acl_clear_perms(perms) != 0) {
     350           0 :                 return -1;
     351             :         }
     352             : 
     353        1542 :         if ((perm_mask & SMB_ACL_READ) != 0 &&
     354         711 :             sys_acl_add_perm(perms, SMB_ACL_READ) != 0) {
     355           0 :                 return -1;
     356             :         }
     357             : 
     358        1221 :         if ((perm_mask & SMB_ACL_WRITE) != 0 &&
     359         390 :             sys_acl_add_perm(perms, SMB_ACL_WRITE) != 0) {
     360           0 :                 return -1;
     361             :         }
     362             : 
     363        1362 :         if ((perm_mask & SMB_ACL_EXECUTE) != 0 &&
     364         531 :             sys_acl_add_perm(perms, SMB_ACL_EXECUTE) != 0) {
     365           0 :                 return -1;
     366             :         }
     367             : 
     368         831 :         if (sys_acl_set_permset(entry, perms) != 0) {
     369           0 :                 return -1;
     370             :         }
     371             : 
     372         831 :         return 0;
     373             : }
     374             : 
     375         183 : static SMB_ACL_T make_simple_acl(TALLOC_CTX *mem_ctx,
     376             :                         gid_t gid,
     377             :                         mode_t chmod_mode)
     378             : {
     379         183 :         mode_t mode = SMB_ACL_READ|SMB_ACL_WRITE|SMB_ACL_EXECUTE;
     380             : 
     381         183 :         mode_t mode_user = (chmod_mode & 0700) >> 6;
     382         183 :         mode_t mode_group = (chmod_mode & 070) >> 3;
     383         183 :         mode_t mode_other = chmod_mode &  07;
     384             :         SMB_ACL_ENTRY_T entry;
     385         183 :         SMB_ACL_T acl = sys_acl_init(mem_ctx);
     386             : 
     387         183 :         if (!acl) {
     388           0 :                 return NULL;
     389             :         }
     390             : 
     391         183 :         if (sys_acl_create_entry(&acl, &entry) != 0) {
     392           0 :                 TALLOC_FREE(acl);
     393           0 :                 return NULL;
     394             :         }
     395             : 
     396         183 :         if (sys_acl_set_tag_type(entry, SMB_ACL_USER_OBJ) != 0) {
     397           0 :                 TALLOC_FREE(acl);
     398           0 :                 return NULL;
     399             :         }
     400             : 
     401         183 :         if (set_acl_entry_perms(entry, mode_user) != 0) {
     402           0 :                 TALLOC_FREE(acl);
     403           0 :                 return NULL;
     404             :         }
     405             : 
     406         183 :         if (sys_acl_create_entry(&acl, &entry) != 0) {
     407           0 :                 TALLOC_FREE(acl);
     408           0 :                 return NULL;
     409             :         }
     410             : 
     411         183 :         if (sys_acl_set_tag_type(entry, SMB_ACL_GROUP_OBJ) != 0) {
     412           0 :                 TALLOC_FREE(acl);
     413           0 :                 return NULL;
     414             :         }
     415             : 
     416         183 :         if (set_acl_entry_perms(entry, mode_group) != 0) {
     417           0 :                 TALLOC_FREE(acl);
     418           0 :                 return NULL;
     419             :         }
     420             : 
     421         183 :         if (sys_acl_create_entry(&acl, &entry) != 0) {
     422           0 :                 TALLOC_FREE(acl);
     423           0 :                 return NULL;
     424             :         }
     425             : 
     426         183 :         if (sys_acl_set_tag_type(entry, SMB_ACL_OTHER) != 0) {
     427           0 :                 TALLOC_FREE(acl);
     428           0 :                 return NULL;
     429             :         }
     430             : 
     431         183 :         if (set_acl_entry_perms(entry, mode_other) != 0) {
     432           0 :                 TALLOC_FREE(acl);
     433           0 :                 return NULL;
     434             :         }
     435             : 
     436         183 :         if (gid != -1) {
     437          99 :                 if (sys_acl_create_entry(&acl, &entry) != 0) {
     438           0 :                         TALLOC_FREE(acl);
     439           0 :                         return NULL;
     440             :                 }
     441             : 
     442          99 :                 if (sys_acl_set_tag_type(entry, SMB_ACL_GROUP) != 0) {
     443           0 :                         TALLOC_FREE(acl);
     444           0 :                         return NULL;
     445             :                 }
     446             : 
     447          99 :                 if (sys_acl_set_qualifier(entry, &gid) != 0) {
     448           0 :                         TALLOC_FREE(acl);
     449           0 :                         return NULL;
     450             :                 }
     451             : 
     452          99 :                 if (set_acl_entry_perms(entry, mode_group) != 0) {
     453           0 :                         TALLOC_FREE(acl);
     454           0 :                         return NULL;
     455             :                 }
     456             :         }
     457             : 
     458         183 :         if (sys_acl_create_entry(&acl, &entry) != 0) {
     459           0 :                 TALLOC_FREE(acl);
     460           0 :                 return NULL;
     461             :         }
     462             : 
     463         183 :         if (sys_acl_set_tag_type(entry, SMB_ACL_MASK) != 0) {
     464           0 :                 TALLOC_FREE(acl);
     465           0 :                 return NULL;
     466             :         }
     467             : 
     468         183 :         if (set_acl_entry_perms(entry, mode) != 0) {
     469           0 :                 TALLOC_FREE(acl);
     470           0 :                 return NULL;
     471             :         }
     472             : 
     473         183 :         return acl;
     474             : }
     475             : 
     476             : /*
     477             :   set a simple ACL on a file, as a test
     478             :  */
     479         183 : static PyObject *py_smbd_set_simple_acl(PyObject *self, PyObject *args, PyObject *kwargs)
     480             : {
     481         183 :         const char * const kwnames[] = {
     482             :                 "fname",
     483             :                 "mode",
     484             :                 "session_info",
     485             :                 "gid",
     486             :                 "service",
     487             :                 NULL
     488             :         };
     489         183 :         char *fname, *service = NULL;
     490         183 :         PyObject *py_session = Py_None;
     491         183 :         struct auth_session_info *session_info = NULL;
     492             :         int ret;
     493         183 :         int mode, gid = -1;
     494             :         SMB_ACL_T acl;
     495             :         TALLOC_CTX *frame;
     496             :         connection_struct *conn;
     497             : 
     498         183 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO|iz",
     499             :                                          discard_const_p(char *, kwnames),
     500             :                                          &fname,
     501             :                                          &mode,
     502             :                                          &py_session,
     503             :                                          &gid,
     504             :                                          &service))
     505           0 :                 return NULL;
     506             : 
     507         183 :         if (!py_check_dcerpc_type(py_session,
     508             :                                   "samba.dcerpc.auth",
     509             :                                   "session_info")) {
     510           0 :                 return NULL;
     511             :         }
     512         183 :         session_info = pytalloc_get_type(py_session,
     513             :                                          struct auth_session_info);
     514         183 :         if (session_info == NULL) {
     515           0 :                 PyErr_Format(PyExc_TypeError,
     516             :                              "Expected auth_session_info for session_info argument got %s",
     517             :                              pytalloc_get_name(py_session));
     518           0 :                 return NULL;
     519             :         }
     520             : 
     521         183 :         frame = talloc_stackframe();
     522             : 
     523         183 :         acl = make_simple_acl(frame, gid, mode);
     524         183 :         if (acl == NULL) {
     525           0 :                 TALLOC_FREE(frame);
     526           0 :                 return NULL;
     527             :         }
     528             : 
     529         183 :         conn = get_conn_tos(service, session_info);
     530         183 :         if (!conn) {
     531           0 :                 TALLOC_FREE(frame);
     532           0 :                 return NULL;
     533             :         }
     534             : 
     535         183 :         ret = set_sys_acl_conn(fname, SMB_ACL_TYPE_ACCESS, acl, conn);
     536             : 
     537         183 :         if (ret != 0) {
     538           0 :                 TALLOC_FREE(frame);
     539           0 :                 errno = ret;
     540           0 :                 return PyErr_SetFromErrno(PyExc_OSError);
     541             :         }
     542             : 
     543         183 :         TALLOC_FREE(frame);
     544             : 
     545         183 :         Py_RETURN_NONE;
     546             : }
     547             : 
     548             : /*
     549             :   chown a file
     550             :  */
     551          75 : static PyObject *py_smbd_chown(PyObject *self, PyObject *args, PyObject *kwargs)
     552             : {
     553          75 :         const char * const kwnames[] = {
     554             :                 "fname",
     555             :                 "uid",
     556             :                 "gid",
     557             :                 "session_info",
     558             :                 "service",
     559             :                 NULL
     560             :         };
     561             :         connection_struct *conn;
     562             :         int ret;
     563             :         NTSTATUS status;
     564          75 :         char *fname, *service = NULL;
     565          75 :         PyObject *py_session = Py_None;
     566          75 :         struct auth_session_info *session_info = NULL;
     567             :         int uid, gid;
     568             :         TALLOC_CTX *frame;
     569          75 :         struct files_struct *fsp = NULL;
     570             : 
     571          75 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siiO|z",
     572             :                                          discard_const_p(char *, kwnames),
     573             :                                          &fname,
     574             :                                          &uid,
     575             :                                          &gid,
     576             :                                          &py_session,
     577             :                                          &service))
     578           0 :                 return NULL;
     579             : 
     580          75 :         if (!py_check_dcerpc_type(py_session,
     581             :                                   "samba.dcerpc.auth",
     582             :                                   "session_info")) {
     583           0 :                 return NULL;
     584             :         }
     585          75 :         session_info = pytalloc_get_type(py_session,
     586             :                                          struct auth_session_info);
     587          75 :         if (session_info == NULL) {
     588           0 :                 PyErr_Format(PyExc_TypeError,
     589             :                              "Expected auth_session_info for session_info argument got %s",
     590             :                              pytalloc_get_name(py_session));
     591           0 :                 return NULL;
     592             :         }
     593             : 
     594          75 :         frame = talloc_stackframe();
     595             : 
     596          75 :         conn = get_conn_tos(service, session_info);
     597          75 :         if (!conn) {
     598           0 :                 TALLOC_FREE(frame);
     599           0 :                 return NULL;
     600             :         }
     601             : 
     602             :         /* first, try to open it as a file with flag O_RDWR */
     603          75 :         status = init_files_struct(frame,
     604             :                                    fname,
     605             :                                    conn,
     606             :                                    O_RDWR,
     607             :                                    &fsp);
     608          75 :         if (!NT_STATUS_IS_OK(status) && errno == EISDIR) {
     609             :                 /* if fail, try to open as dir */
     610          12 :                 status = init_files_struct(frame,
     611             :                                            fname,
     612             :                                            conn,
     613             :                                            DIRECTORY_FLAGS,
     614             :                                            &fsp);
     615             :         }
     616             : 
     617          75 :         if (!NT_STATUS_IS_OK(status)) {
     618           0 :                 DBG_ERR("init_files_struct failed: %s\n",
     619             :                         nt_errstr(status));
     620           0 :                 if (fsp != NULL) {
     621           0 :                         SMB_VFS_CLOSE(fsp);
     622             :                 }
     623           0 :                 TALLOC_FREE(frame);
     624             :                 /*
     625             :                  * The following macro raises a python
     626             :                  * error then returns NULL.
     627             :                  */
     628           0 :                 PyErr_NTSTATUS_IS_ERR_RAISE(status);
     629             :         }
     630             : 
     631          75 :         ret = SMB_VFS_FCHOWN(fsp, uid, gid);
     632          75 :         if (ret != 0) {
     633           0 :                 int saved_errno = errno;
     634           0 :                 SMB_VFS_CLOSE(fsp);
     635           0 :                 TALLOC_FREE(frame);
     636           0 :                 errno = saved_errno;
     637           0 :                 return PyErr_SetFromErrno(PyExc_OSError);
     638             :         }
     639             : 
     640          75 :         SMB_VFS_CLOSE(fsp);
     641          75 :         TALLOC_FREE(frame);
     642             : 
     643          75 :         Py_RETURN_NONE;
     644             : }
     645             : 
     646             : /*
     647             :   unlink a file
     648             :  */
     649         279 : static PyObject *py_smbd_unlink(PyObject *self, PyObject *args, PyObject *kwargs)
     650             : {
     651         279 :         const char * const kwnames[] = {
     652             :                 "fname",
     653             :                 "session_info",
     654             :                 "service",
     655             :                 NULL
     656             :         };
     657             :         connection_struct *conn;
     658             :         int ret;
     659         279 :         struct smb_filename *smb_fname = NULL;
     660         279 :         struct smb_filename *parent_fname = NULL;
     661         279 :         struct smb_filename *at_fname = NULL;
     662         279 :         PyObject *py_session = Py_None;
     663         279 :         struct auth_session_info *session_info = NULL;
     664         279 :         char *fname, *service = NULL;
     665             :         TALLOC_CTX *frame;
     666             :         NTSTATUS status;
     667             : 
     668         279 :         frame = talloc_stackframe();
     669             : 
     670         279 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO|z",
     671             :                                          discard_const_p(char *, kwnames),
     672             :                                          &fname,
     673             :                                          &py_session ,
     674             :                                          &service)) {
     675           0 :                 TALLOC_FREE(frame);
     676           0 :                 return NULL;
     677             :         }
     678             : 
     679         279 :         if (!py_check_dcerpc_type(py_session,
     680             :                                   "samba.dcerpc.auth",
     681             :                                   "session_info")) {
     682           0 :                 TALLOC_FREE(frame);
     683           0 :                 return NULL;
     684             :         }
     685         279 :         session_info = pytalloc_get_type(py_session,
     686             :                                          struct auth_session_info);
     687         279 :         if (session_info == NULL) {
     688           0 :                 PyErr_Format(PyExc_TypeError,
     689             :                              "Expected auth_session_info for session_info argument got %s",
     690             :                              pytalloc_get_name(py_session));
     691           0 :                 TALLOC_FREE(frame);
     692           0 :                 return NULL;
     693             :         }
     694             : 
     695         279 :         conn = get_conn_tos(service, session_info);
     696         279 :         if (!conn) {
     697           0 :                 TALLOC_FREE(frame);
     698           0 :                 return NULL;
     699             :         }
     700             : 
     701         279 :         smb_fname = synthetic_smb_fname_split(frame,
     702             :                                         fname,
     703         279 :                                         lp_posix_pathnames());
     704         279 :         if (smb_fname == NULL) {
     705           0 :                 TALLOC_FREE(frame);
     706           0 :                 return PyErr_NoMemory();
     707             :         }
     708             : 
     709         279 :         status = parent_pathref(frame,
     710             :                                 conn->cwd_fsp,
     711             :                                 smb_fname,
     712             :                                 &parent_fname,
     713             :                                 &at_fname);
     714         279 :         if (!NT_STATUS_IS_OK(status)) {
     715           0 :                 TALLOC_FREE(frame);
     716           0 :                 return PyErr_NoMemory();
     717             :         }
     718             : 
     719         279 :         ret = SMB_VFS_UNLINKAT(conn,
     720             :                         parent_fname->fsp,
     721             :                         at_fname,
     722             :                         0);
     723         279 :         if (ret != 0) {
     724           0 :                 TALLOC_FREE(frame);
     725           0 :                 errno = ret;
     726           0 :                 return PyErr_SetFromErrno(PyExc_OSError);
     727             :         }
     728             : 
     729         279 :         TALLOC_FREE(frame);
     730             : 
     731         279 :         Py_RETURN_NONE;
     732             : }
     733             : 
     734             : /*
     735             :   check if we have ACL support
     736             :  */
     737           0 : static PyObject *py_smbd_have_posix_acls(PyObject *self,
     738             :                 PyObject *Py_UNUSED(ignored))
     739             : {
     740             : #ifdef HAVE_POSIX_ACLS
     741           0 :         return PyBool_FromLong(true);
     742             : #else
     743             :         return PyBool_FromLong(false);
     744             : #endif
     745             : }
     746             : 
     747             : /*
     748             :   set the NT ACL on a file
     749             :  */
     750        1895 : static PyObject *py_smbd_set_nt_acl(PyObject *self, PyObject *args, PyObject *kwargs)
     751             : {
     752        1895 :         const char * const kwnames[] = {
     753             :                 "fname",
     754             :                 "security_info_sent",
     755             :                 "sd",
     756             :                 "session_info",
     757             :                 "service",
     758             :                 NULL
     759             :         };
     760             : 
     761             :         NTSTATUS status;
     762        1895 :         char *fname, *service = NULL;
     763             :         int security_info_sent;
     764             :         PyObject *py_sd;
     765             :         struct security_descriptor *sd;
     766        1895 :         PyObject *py_session = Py_None;
     767        1895 :         struct auth_session_info *session_info = NULL;
     768             :         connection_struct *conn;
     769             :         TALLOC_CTX *frame;
     770             : 
     771        1895 :         frame = talloc_stackframe();
     772             : 
     773        1895 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siOO|z",
     774             :                                          discard_const_p(char *, kwnames),
     775             :                                          &fname,
     776             :                                          &security_info_sent,
     777             :                                          &py_sd,
     778             :                                          &py_session,
     779             :                                          &service)) {
     780           0 :                 TALLOC_FREE(frame);
     781           0 :                 return NULL;
     782             :         }
     783             : 
     784        1895 :         if (!py_check_dcerpc_type(py_sd, "samba.dcerpc.security", "descriptor")) {
     785           0 :                 TALLOC_FREE(frame);
     786           0 :                 return NULL;
     787             :         }
     788             : 
     789        1895 :         if (!py_check_dcerpc_type(py_session,
     790             :                                   "samba.dcerpc.auth",
     791             :                                   "session_info")) {
     792           0 :                 TALLOC_FREE(frame);
     793           0 :                 return NULL;
     794             :         }
     795        1895 :         session_info = pytalloc_get_type(py_session,
     796             :                                          struct auth_session_info);
     797        1895 :         if (session_info == NULL) {
     798           0 :                 PyErr_Format(PyExc_TypeError,
     799             :                              "Expected auth_session_info for session_info argument got %s",
     800             :                              pytalloc_get_name(py_session));
     801           0 :                 return NULL;
     802             :         }
     803             : 
     804        1895 :         conn = get_conn_tos(service, session_info);
     805        1895 :         if (!conn) {
     806           0 :                 TALLOC_FREE(frame);
     807           0 :                 return NULL;
     808             :         }
     809             : 
     810        1895 :         sd = pytalloc_get_type(py_sd, struct security_descriptor);
     811             : 
     812        1895 :         status = set_nt_acl_conn(fname, security_info_sent, sd, conn);
     813        1895 :         TALLOC_FREE(frame);
     814        1895 :         PyErr_NTSTATUS_IS_ERR_RAISE(status);
     815             : 
     816        1895 :         Py_RETURN_NONE;
     817             : }
     818             : 
     819             : /*
     820             :   Return the NT ACL on a file
     821             :  */
     822         478 : static PyObject *py_smbd_get_nt_acl(PyObject *self, PyObject *args, PyObject *kwargs)
     823             : {
     824         478 :         const char * const kwnames[] = {
     825             :                 "fname",
     826             :                 "security_info_wanted",
     827             :                 "session_info",
     828             :                 "service",
     829             :                 NULL
     830             :         };
     831         478 :         char *fname, *service = NULL;
     832             :         int security_info_wanted;
     833             :         PyObject *py_sd;
     834             :         struct security_descriptor *sd;
     835         478 :         TALLOC_CTX *frame = talloc_stackframe();
     836         478 :         PyObject *py_session = Py_None;
     837         478 :         struct auth_session_info *session_info = NULL;
     838             :         connection_struct *conn;
     839             :         NTSTATUS status;
     840         478 :         int ret = 1;
     841             : 
     842         478 :         ret = PyArg_ParseTupleAndKeywords(args,
     843             :                                           kwargs,
     844             :                                           "siO|z",
     845             :                                           discard_const_p(char *, kwnames),
     846             :                                           &fname,
     847             :                                           &security_info_wanted,
     848             :                                           &py_session,
     849             :                                           &service);
     850         478 :         if (!ret) {
     851           0 :                 TALLOC_FREE(frame);
     852           0 :                 return NULL;
     853             :         }
     854             : 
     855         478 :         if (!py_check_dcerpc_type(py_session,
     856             :                                   "samba.dcerpc.auth",
     857             :                                   "session_info")) {
     858           0 :                 TALLOC_FREE(frame);
     859           0 :                 return NULL;
     860             :         }
     861         478 :         session_info = pytalloc_get_type(py_session,
     862             :                                          struct auth_session_info);
     863         478 :         if (session_info == NULL) {
     864           0 :                 PyErr_Format(
     865             :                         PyExc_TypeError,
     866             :                         "Expected auth_session_info for "
     867             :                         "session_info argument got %s",
     868             :                         pytalloc_get_name(py_session));
     869           0 :                 return NULL;
     870             :         }
     871             : 
     872         478 :         conn = get_conn_tos(service, session_info);
     873         478 :         if (!conn) {
     874           0 :                 TALLOC_FREE(frame);
     875           0 :                 return NULL;
     876             :         }
     877             : 
     878         478 :         status = get_nt_acl_conn(frame, fname, conn, security_info_wanted, &sd);
     879         478 :         PyErr_NTSTATUS_IS_ERR_RAISE(status);
     880             : 
     881         478 :         py_sd = py_return_ndr_struct("samba.dcerpc.security", "descriptor", sd, sd);
     882             : 
     883         478 :         TALLOC_FREE(frame);
     884             : 
     885         478 :         return py_sd;
     886             : }
     887             : 
     888             : /*
     889             :   set the posix (or similar) ACL on a file
     890             :  */
     891           0 : static PyObject *py_smbd_set_sys_acl(PyObject *self, PyObject *args, PyObject *kwargs)
     892             : {
     893           0 :         const char * const kwnames[] = {
     894             :                 "fname",
     895             :                 "acl_type",
     896             :                 "acl",
     897             :                 "session_info",
     898             :                 "service",
     899             :                 NULL
     900             :         };
     901           0 :         TALLOC_CTX *frame = talloc_stackframe();
     902             :         int ret;
     903           0 :         char *fname, *service = NULL;
     904             :         PyObject *py_acl;
     905           0 :         PyObject *py_session = Py_None;
     906           0 :         struct auth_session_info *session_info = NULL;
     907             :         struct smb_acl_t *acl;
     908             :         int acl_type;
     909             :         connection_struct *conn;
     910             : 
     911           0 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siOO|z",
     912             :                                          discard_const_p(char *, kwnames),
     913             :                                          &fname,
     914             :                                          &acl_type,
     915             :                                          &py_acl,
     916             :                                          &py_session,
     917             :                                          &service)) {
     918           0 :                 TALLOC_FREE(frame);
     919           0 :                 return NULL;
     920             :         }
     921             : 
     922           0 :         if (!py_check_dcerpc_type(py_acl, "samba.dcerpc.smb_acl", "t")) {
     923           0 :                 TALLOC_FREE(frame);
     924           0 :                 return NULL;
     925             :         }
     926             : 
     927           0 :         if (!py_check_dcerpc_type(py_session,
     928             :                                   "samba.dcerpc.auth",
     929             :                                   "session_info")) {
     930           0 :                 TALLOC_FREE(frame);
     931           0 :                 return NULL;
     932             :         }
     933           0 :         session_info = pytalloc_get_type(py_session,
     934             :                                          struct auth_session_info);
     935           0 :         if (session_info == NULL) {
     936           0 :                 PyErr_Format(PyExc_TypeError,
     937             :                              "Expected auth_session_info for session_info argument got %s",
     938             :                              pytalloc_get_name(py_session));
     939           0 :                 TALLOC_FREE(frame);
     940           0 :                 return NULL;
     941             :         }
     942             : 
     943           0 :         conn = get_conn_tos(service, session_info);
     944           0 :         if (!conn) {
     945           0 :                 TALLOC_FREE(frame);
     946           0 :                 return NULL;
     947             :         }
     948             : 
     949           0 :         acl = pytalloc_get_type(py_acl, struct smb_acl_t);
     950             : 
     951           0 :         ret = set_sys_acl_conn(fname, acl_type, acl, conn);
     952           0 :         if (ret != 0) {
     953           0 :                 TALLOC_FREE(frame);
     954           0 :                 errno = ret;
     955           0 :                 return PyErr_SetFromErrno(PyExc_OSError);
     956             :         }
     957             : 
     958           0 :         TALLOC_FREE(frame);
     959           0 :         Py_RETURN_NONE;
     960             : }
     961             : 
     962             : /*
     963             :   Return the posix (or similar) ACL on a file
     964             :  */
     965          96 : static PyObject *py_smbd_get_sys_acl(PyObject *self, PyObject *args, PyObject *kwargs)
     966             : {
     967          96 :         const char * const kwnames[] = {
     968             :                 "fname",
     969             :                 "acl_type",
     970             :                 "session_info",
     971             :                 "service",
     972             :                 NULL
     973             :         };
     974             :         char *fname;
     975             :         PyObject *py_acl;
     976          96 :         PyObject *py_session = Py_None;
     977          96 :         struct auth_session_info *session_info = NULL;
     978             :         struct smb_acl_t *acl;
     979             :         int acl_type;
     980          96 :         TALLOC_CTX *frame = talloc_stackframe();
     981             :         connection_struct *conn;
     982          96 :         char *service = NULL;
     983          96 :         struct smb_filename *smb_fname = NULL;
     984             :         NTSTATUS status;
     985             :         int ret;
     986             : 
     987          96 :         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "siO|z",
     988             :                                          discard_const_p(char *, kwnames),
     989             :                                          &fname,
     990             :                                          &acl_type,
     991             :                                          &py_session,
     992             :                                          &service)) {
     993           0 :                 TALLOC_FREE(frame);
     994           0 :                 return NULL;
     995             :         }
     996             : 
     997          96 :         if (!py_check_dcerpc_type(py_session,
     998             :                                   "samba.dcerpc.auth",
     999             :                                   "session_info")) {
    1000           0 :                 TALLOC_FREE(frame);
    1001           0 :                 return NULL;
    1002             :         }
    1003          96 :         session_info = pytalloc_get_type(py_session,
    1004             :                                          struct auth_session_info);
    1005          96 :         if (session_info == NULL) {
    1006           0 :                 PyErr_Format(PyExc_TypeError,
    1007             :                              "Expected auth_session_info for session_info argument got %s",
    1008             :                              pytalloc_get_name(py_session));
    1009           0 :                 TALLOC_FREE(frame);
    1010           0 :                 return NULL;
    1011             :         }
    1012             : 
    1013          96 :         conn = get_conn_tos(service, session_info);
    1014          96 :         if (!conn) {
    1015           0 :                 TALLOC_FREE(frame);
    1016           0 :                 return NULL;
    1017             :         }
    1018             : 
    1019          96 :         smb_fname = synthetic_smb_fname_split(frame,
    1020             :                                         fname,
    1021          96 :                                         lp_posix_pathnames());
    1022          96 :         if (smb_fname == NULL) {
    1023           0 :                 TALLOC_FREE(frame);
    1024           0 :                 return NULL;
    1025             :         }
    1026          96 :         ret = vfs_stat(conn, smb_fname);
    1027          96 :         if (ret == -1) {
    1028           0 :                 TALLOC_FREE(frame);
    1029           0 :                 return PyErr_SetFromErrno(PyExc_OSError);
    1030             :         }
    1031             : 
    1032          96 :         status = openat_pathref_fsp(conn->cwd_fsp, smb_fname);
    1033          96 :         if (!NT_STATUS_IS_OK(status)) {
    1034           0 :                 TALLOC_FREE(frame);
    1035           0 :                 PyErr_SetNTSTATUS(status);
    1036           0 :                 return NULL;
    1037             :         }
    1038             : 
    1039          96 :         acl = SMB_VFS_SYS_ACL_GET_FD(smb_fname->fsp, acl_type, frame);
    1040          96 :         if (!acl) {
    1041           0 :                 TALLOC_FREE(frame);
    1042           0 :                 return PyErr_SetFromErrno(PyExc_OSError);
    1043             :         }
    1044             : 
    1045          96 :         py_acl = py_return_ndr_struct("samba.dcerpc.smb_acl", "t", acl, acl);
    1046             : 
    1047          96 :         TALLOC_FREE(frame);
    1048             : 
    1049          96 :         return py_acl;
    1050             : }
    1051             : 
    1052         550 : static PyObject *py_smbd_mkdir(PyObject *self, PyObject *args, PyObject *kwargs)
    1053             : {
    1054         550 :         const char * const kwnames[] = {
    1055             :                 "fname",
    1056             :                 "session_info",
    1057             :                 "service",
    1058             :                 NULL
    1059             :         };
    1060         550 :         char *fname, *service = NULL;
    1061         550 :         PyObject *py_session = Py_None;
    1062         550 :         struct auth_session_info *session_info = NULL;
    1063         550 :         TALLOC_CTX *frame = talloc_stackframe();
    1064         550 :         struct connection_struct *conn = NULL;
    1065         550 :         struct smb_filename *smb_fname = NULL;
    1066         550 :         struct smb_filename *parent_fname = NULL;
    1067         550 :         struct smb_filename *base_name = NULL;
    1068             :         NTSTATUS status;
    1069             :         int ret;
    1070             :         mode_t saved_umask;
    1071             : 
    1072         550 :         if (!PyArg_ParseTupleAndKeywords(args,
    1073             :                                          kwargs,
    1074             :                                          "sO|z",
    1075             :                                          discard_const_p(char *,
    1076             :                                                          kwnames),
    1077             :                                          &fname,
    1078             :                                          &py_session,
    1079             :                                          &service)) {
    1080           0 :                 TALLOC_FREE(frame);
    1081           0 :                 return NULL;
    1082             :         }
    1083             : 
    1084         550 :         if (!py_check_dcerpc_type(py_session,
    1085             :                                   "samba.dcerpc.auth",
    1086             :                                   "session_info")) {
    1087           0 :                 TALLOC_FREE(frame);
    1088           0 :                 return NULL;
    1089             :         }
    1090         550 :         session_info = pytalloc_get_type(py_session,
    1091             :                                          struct auth_session_info);
    1092         550 :         if (session_info == NULL) {
    1093           0 :                 PyErr_Format(PyExc_TypeError,
    1094             :                              "Expected auth_session_info for session_info argument got %s",
    1095             :                              pytalloc_get_name(py_session));
    1096           0 :                 TALLOC_FREE(frame);
    1097           0 :                 return NULL;
    1098             :         }
    1099             : 
    1100         550 :         conn = get_conn_tos(service, session_info);
    1101         550 :         if (!conn) {
    1102           0 :                 TALLOC_FREE(frame);
    1103           0 :                 return NULL;
    1104             :         }
    1105             : 
    1106         550 :         smb_fname = synthetic_smb_fname(talloc_tos(),
    1107             :                                         fname,
    1108             :                                         NULL,
    1109             :                                         NULL,
    1110             :                                         0,
    1111         550 :                                         lp_posix_pathnames() ?
    1112             :                                         SMB_FILENAME_POSIX_PATH : 0);
    1113             : 
    1114         550 :         if (smb_fname == NULL) {
    1115           0 :                 TALLOC_FREE(frame);
    1116           0 :                 return NULL;
    1117             :         }
    1118             : 
    1119         550 :         status = parent_pathref(talloc_tos(),
    1120             :                                 conn->cwd_fsp,
    1121             :                                 smb_fname,
    1122             :                                 &parent_fname,
    1123             :                                 &base_name);
    1124         550 :         if (!NT_STATUS_IS_OK(status)) {
    1125           0 :                 TALLOC_FREE(frame);
    1126           0 :                 return NULL;
    1127             :         }
    1128             : 
    1129             :         /* we want total control over the permissions on created files,
    1130             :            so set our umask to 0 */
    1131         550 :         saved_umask = umask(0);
    1132             : 
    1133         550 :         ret = SMB_VFS_MKDIRAT(conn,
    1134             :                         parent_fname->fsp,
    1135             :                         base_name,
    1136             :                         00755);
    1137             : 
    1138         550 :         umask(saved_umask);
    1139             : 
    1140         550 :         if (ret == -1) {
    1141           0 :                 DBG_ERR("mkdirat error=%d (%s)\n", errno, strerror(errno));
    1142           0 :                 TALLOC_FREE(frame);
    1143           0 :                 return NULL;
    1144             :         }
    1145             : 
    1146         550 :         TALLOC_FREE(frame);
    1147         550 :         Py_RETURN_NONE;
    1148             : }
    1149             : 
    1150             : 
    1151             : /*
    1152             :   Create an empty file
    1153             :  */
    1154         135 : static PyObject *py_smbd_create_file(PyObject *self, PyObject *args, PyObject *kwargs)
    1155             : {
    1156         135 :         const char * const kwnames[] = {
    1157             :                 "fname",
    1158             :                 "session_info",
    1159             :                 "service",
    1160             :                 NULL
    1161             :         };
    1162         135 :         char *fname, *service = NULL;
    1163         135 :         PyObject *py_session = Py_None;
    1164         135 :         struct auth_session_info *session_info = NULL;
    1165         135 :         TALLOC_CTX *frame = talloc_stackframe();
    1166         135 :         struct connection_struct *conn = NULL;
    1167         135 :         struct files_struct *fsp = NULL;
    1168             :         NTSTATUS status;
    1169             : 
    1170         135 :         if (!PyArg_ParseTupleAndKeywords(args,
    1171             :                                          kwargs,
    1172             :                                          "sO|z",
    1173             :                                          discard_const_p(char *,
    1174             :                                                          kwnames),
    1175             :                                          &fname,
    1176             :                                          &py_session,
    1177             :                                          &service)) {
    1178           0 :                 TALLOC_FREE(frame);
    1179           0 :                 return NULL;
    1180             :         }
    1181             : 
    1182         135 :         if (!py_check_dcerpc_type(py_session,
    1183             :                                   "samba.dcerpc.auth",
    1184             :                                   "session_info")) {
    1185           0 :                 TALLOC_FREE(frame);
    1186           0 :                 return NULL;
    1187             :         }
    1188         135 :         session_info = pytalloc_get_type(py_session,
    1189             :                                          struct auth_session_info);
    1190         135 :         if (session_info == NULL) {
    1191           0 :                 PyErr_Format(PyExc_TypeError,
    1192             :                              "Expected auth_session_info for session_info argument got %s",
    1193             :                              pytalloc_get_name(py_session));
    1194           0 :                 TALLOC_FREE(frame);
    1195           0 :                 return NULL;
    1196             :         }
    1197             : 
    1198         135 :         conn = get_conn_tos(service, session_info);
    1199         135 :         if (!conn) {
    1200           0 :                 TALLOC_FREE(frame);
    1201           0 :                 return NULL;
    1202             :         }
    1203             : 
    1204         135 :         status = init_files_struct(frame,
    1205             :                                    fname,
    1206             :                                    conn,
    1207             :                                    O_CREAT|O_EXCL|O_RDWR,
    1208             :                                    &fsp);
    1209         135 :         if (!NT_STATUS_IS_OK(status)) {
    1210           0 :                 DBG_ERR("init_files_struct failed: %s\n",
    1211             :                         nt_errstr(status));
    1212         135 :         } else if (fsp != NULL) {
    1213         135 :                 SMB_VFS_CLOSE(fsp);
    1214             :         }
    1215             : 
    1216         135 :         TALLOC_FREE(frame);
    1217         135 :         PyErr_NTSTATUS_NOT_OK_RAISE(status);
    1218         135 :         Py_RETURN_NONE;
    1219             : }
    1220             : 
    1221             : 
    1222             : static PyMethodDef py_smbd_methods[] = {
    1223             :         { "have_posix_acls",
    1224             :                 (PyCFunction)py_smbd_have_posix_acls, METH_NOARGS,
    1225             :                 NULL },
    1226             :         { "set_simple_acl",
    1227             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_set_simple_acl),
    1228             :                 METH_VARARGS|METH_KEYWORDS,
    1229             :                 NULL },
    1230             :         { "set_nt_acl",
    1231             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_set_nt_acl),
    1232             :                 METH_VARARGS|METH_KEYWORDS,
    1233             :                 NULL },
    1234             :         { "get_nt_acl",
    1235             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_get_nt_acl),
    1236             :                 METH_VARARGS|METH_KEYWORDS,
    1237             :                 NULL },
    1238             :         { "get_sys_acl",
    1239             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_get_sys_acl),
    1240             :                 METH_VARARGS|METH_KEYWORDS,
    1241             :                 NULL },
    1242             :         { "set_sys_acl",
    1243             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_set_sys_acl),
    1244             :                 METH_VARARGS|METH_KEYWORDS,
    1245             :                 NULL },
    1246             :         { "chown",
    1247             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_chown),
    1248             :                 METH_VARARGS|METH_KEYWORDS,
    1249             :                 NULL },
    1250             :         { "unlink",
    1251             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_unlink),
    1252             :                 METH_VARARGS|METH_KEYWORDS,
    1253             :                 NULL },
    1254             :         { "mkdir",
    1255             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_mkdir),
    1256             :                 METH_VARARGS|METH_KEYWORDS,
    1257             :                 NULL },
    1258             :         { "create_file",
    1259             :                 PY_DISCARD_FUNC_SIG(PyCFunction, py_smbd_create_file),
    1260             :                 METH_VARARGS|METH_KEYWORDS,
    1261             :                 NULL },
    1262             :         {0}
    1263             : };
    1264             : 
    1265             : void initsmbd(void);
    1266             : 
    1267             : static struct PyModuleDef moduledef = {
    1268             :     PyModuleDef_HEAD_INIT,
    1269             :     .m_name = "smbd",
    1270             :     .m_doc = "Python bindings for the smbd file server.",
    1271             :     .m_size = -1,
    1272             :     .m_methods = py_smbd_methods,
    1273             : };
    1274             : 
    1275        1535 : MODULE_INIT_FUNC(smbd)
    1276             : {
    1277        1535 :         PyObject *m = NULL;
    1278             : 
    1279        1535 :         m = PyModule_Create(&moduledef);
    1280        1535 :         return m;
    1281             : }

Generated by: LCOV version 1.13