16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * $Id: file.c,v 1.4 2004/12/13 00:25:21 lindak Exp $
33 */
34
35 /*
36 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
37 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
38 * Use is subject to license terms.
39 */
40
41 #include <sys/param.h>
42 #include <sys/ioctl.h>
43 #include <sys/time.h>
44 #include <sys/mount.h>
45 #include <fcntl.h>
46 #include <ctype.h>
47 #include <errno.h>
48 #include <stdio.h>
49 #include <string.h>
50 #include <strings.h>
51 #include <stdlib.h>
52 #include <pwd.h>
53 #include <grp.h>
54 #include <unistd.h>
55 #include <libintl.h>
56
57 #include <sys/types.h>
58 #include <sys/file.h>
59
60 #include <netsmb/smb.h>
61 #include <netsmb/smb_lib.h>
62
63 #include "private.h"
64
65 int
66 smb_fh_close(int fd)
67 {
68 return (close(fd));
69 }
70
71 int
72 smb_fh_ntcreate(
73 struct smb_ctx *ctx, char *path,
74 int req_acc, int efattr, int share_acc,
75 int open_disp, int create_opts)
76 {
77 smbioc_ntcreate_t ioc;
78 int err, nmlen;
79 int new_fd = -1;
80 int32_t from_fd;
81
82 nmlen = strlen(path);
83 if (nmlen >= SMBIOC_MAX_NAME) {
84 err = EINVAL;
85 goto errout;
86 }
87
88 /*
89 * Will represent this SMB-level open as a new
90 * open device handle. Get one, then duplicate
91 * the driver session and tree bindings.
92 */
93 new_fd = smb_open_driver();
94 if (new_fd < 0) {
95 err = errno;
96 goto errout;
97 }
98 from_fd = ctx->ct_dev_fd;
99 if (ioctl(new_fd, SMBIOC_DUP_DEV, &from_fd) == -1) {
100 err = errno;
101 goto errout;
102 }
103
104 /*
105 * Do the SMB-level open with the new dev handle.
106 */
107 bzero(&ioc, sizeof (ioc));
108 strlcpy(ioc.ioc_name, path, SMBIOC_MAX_NAME);
109 ioc.ioc_req_acc = req_acc;
110 ioc.ioc_efattr = efattr;
111 ioc.ioc_share_acc = share_acc;
112 ioc.ioc_open_disp = open_disp;
113 ioc.ioc_creat_opts = create_opts;
114 if (ioctl(new_fd, SMBIOC_NTCREATE, &ioc) == -1) {
115 err = errno;
116 goto errout;
117 }
118
119 return (new_fd);
120
121 errout:
122 if (new_fd != -1)
123 close(new_fd);
124 errno = err;
125 return (-1);
126 }
127
128 /*
129 * Conveinence wrapper for smb_fh_ntcreate
130 * Converts Unix-style open call to NTCreate.
131 */
132 int
133 smb_fh_open(struct smb_ctx *ctx, const char *path, int oflag)
134 {
135 int mode, open_disp, req_acc, share_acc;
136 char *p, *ntpath = NULL;
137 int fd = -1;
138
139 /*
140 * Convert Unix path to NT (backslashes)
141 */
142 ntpath = strdup(path);
143 if (ntpath == NULL)
187 open_disp = NTCREATEX_DISP_OVERWRITE_IF;
188 else
189 open_disp = NTCREATEX_DISP_OPEN_IF;
190 } else {
191 /* Not creating. */
192 if (oflag & FTRUNC)
193 open_disp = NTCREATEX_DISP_OVERWRITE;
194 else
195 open_disp = NTCREATEX_DISP_OPEN;
196 }
197
198 fd = smb_fh_ntcreate(ctx, ntpath,
199 req_acc, SMB_EFA_NORMAL, share_acc, open_disp,
200 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE);
201
202 free(ntpath);
203 return (fd);
204 }
205
206 int
207 smb_fh_read(int fd, off_t offset, size_t count,
208 char *dst)
209 {
210 struct smbioc_rw rwrq;
211
212 bzero(&rwrq, sizeof (rwrq));
213 rwrq.ioc_fh = -1; /* tell driver to supply this */
214 rwrq.ioc_base = dst;
215 rwrq.ioc_cnt = count;
216 rwrq.ioc_offset = offset;
217 if (ioctl(fd, SMBIOC_READ, &rwrq) == -1) {
218 return (-1);
219 }
220 return (rwrq.ioc_cnt);
221 }
222
223 int
224 smb_fh_write(int fd, off_t offset, size_t count,
225 const char *src)
226 {
227 struct smbioc_rw rwrq;
228
229 bzero(&rwrq, sizeof (rwrq));
230 rwrq.ioc_fh = -1; /* tell driver to supply this */
231 rwrq.ioc_base = (char *)src;
232 rwrq.ioc_cnt = count;
233 rwrq.ioc_offset = offset;
234 if (ioctl(fd, SMBIOC_WRITE, &rwrq) == -1) {
235 return (-1);
236 }
237 return (rwrq.ioc_cnt);
238 }
239
240 /*
241 * Do a TRANSACT_NAMED_PIPE, which is basically just a
242 * pipe write and pipe read, all in one round trip.
243 *
244 * tdlen, tdata describe the data to send.
245 * rdlen, rdata on input describe the receive buffer,
246 * and on output *rdlen is the received length.
247 */
248 int
249 smb_fh_xactnp(int fd,
250 int tdlen, const char *tdata, /* transmit */
251 int *rdlen, char *rdata, /* receive */
252 int *more)
253 {
254 int err, rparamcnt;
255 uint16_t setup[2];
256
257 setup[0] = TRANS_TRANSACT_NAMED_PIPE;
258 setup[1] = 0xFFFF; /* driver replaces this */
259 rparamcnt = 0;
260
261 err = smb_t2_request(fd, 2, setup, "\\PIPE\\",
262 0, NULL, /* TX paramcnt, params */
263 tdlen, (void *)tdata,
264 &rparamcnt, NULL, /* no RX params */
265 rdlen, rdata, more);
266
267 if (err)
268 *rdlen = 0;
269
270 return (err);
271 }
|
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * $Id: file.c,v 1.4 2004/12/13 00:25:21 lindak Exp $
33 */
34
35 /*
36 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
37 * Use is subject to license terms.
38 *
39 * Copyright 2018 Nexenta Systems, Inc. All rights reserved.
40 */
41
42 #include <sys/param.h>
43 #include <sys/ioctl.h>
44 #include <sys/time.h>
45 #include <sys/mount.h>
46 #include <fcntl.h>
47 #include <ctype.h>
48 #include <errno.h>
49 #include <stdio.h>
50 #include <string.h>
51 #include <strings.h>
52 #include <stdlib.h>
53 #include <pwd.h>
54 #include <grp.h>
55 #include <unistd.h>
56 #include <libintl.h>
57
58 #include <sys/types.h>
59 #include <sys/file.h>
60
61 #include <netsmb/smb.h>
62 #include <netsmb/smb_lib.h>
63
64 #include "private.h"
65
66 /*
67 * It's not actually necessary to call the CLOSEFH ioctl, but doing it
68 * makes debugging a little easier. If we were to skip the ioctl,
69 * nsmb_close would cleanup the handle, here or in process exit.
70 */
71 int
72 smb_fh_close(int fd)
73 {
74 (void) nsmb_ioctl(fd, SMBIOC_CLOSEFH, NULL);
75 return (nsmb_close(fd));
76 }
77
78 int
79 smb_fh_ntcreate(
80 struct smb_ctx *ctx, char *path,
81 int req_acc, int efattr, int share_acc,
82 int open_disp, int create_opts)
83 {
84 smbioc_ntcreate_t ioc;
85 int err, nmlen;
86 int new_fd = -1;
87 int32_t from_fd;
88
89 nmlen = strlen(path);
90 if (nmlen >= SMBIOC_MAX_NAME) {
91 err = EINVAL;
92 goto errout;
93 }
94
95 /*
96 * Will represent this SMB-level open as a new
97 * open device handle. Get one, then duplicate
98 * the driver session and tree bindings.
99 */
100 new_fd = smb_open_driver();
101 if (new_fd < 0) {
102 err = errno;
103 goto errout;
104 }
105 from_fd = ctx->ct_dev_fd;
106 if (nsmb_ioctl(new_fd, SMBIOC_DUP_DEV, &from_fd) == -1) {
107 err = errno;
108 goto errout;
109 }
110
111 /*
112 * Do the SMB-level open with the new dev handle.
113 */
114 bzero(&ioc, sizeof (ioc));
115 strlcpy(ioc.ioc_name, path, SMBIOC_MAX_NAME);
116 ioc.ioc_req_acc = req_acc;
117 ioc.ioc_efattr = efattr;
118 ioc.ioc_share_acc = share_acc;
119 ioc.ioc_open_disp = open_disp;
120 ioc.ioc_creat_opts = create_opts;
121 if (nsmb_ioctl(new_fd, SMBIOC_NTCREATE, &ioc) == -1) {
122 err = errno;
123 goto errout;
124 }
125
126 return (new_fd);
127
128 errout:
129 if (new_fd != -1)
130 nsmb_close(new_fd);
131 errno = err;
132 return (-1);
133 }
134
135 /*
136 * Conveinence wrapper for smb_fh_ntcreate
137 * Converts Unix-style open call to NTCreate.
138 */
139 int
140 smb_fh_open(struct smb_ctx *ctx, const char *path, int oflag)
141 {
142 int mode, open_disp, req_acc, share_acc;
143 char *p, *ntpath = NULL;
144 int fd = -1;
145
146 /*
147 * Convert Unix path to NT (backslashes)
148 */
149 ntpath = strdup(path);
150 if (ntpath == NULL)
194 open_disp = NTCREATEX_DISP_OVERWRITE_IF;
195 else
196 open_disp = NTCREATEX_DISP_OPEN_IF;
197 } else {
198 /* Not creating. */
199 if (oflag & FTRUNC)
200 open_disp = NTCREATEX_DISP_OVERWRITE;
201 else
202 open_disp = NTCREATEX_DISP_OPEN;
203 }
204
205 fd = smb_fh_ntcreate(ctx, ntpath,
206 req_acc, SMB_EFA_NORMAL, share_acc, open_disp,
207 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE);
208
209 free(ntpath);
210 return (fd);
211 }
212
213 int
214 smb_fh_read(int fd, off64_t offset, size_t count,
215 char *dst)
216 {
217 struct smbioc_rw rwrq;
218
219 bzero(&rwrq, sizeof (rwrq));
220 rwrq.ioc_base = dst;
221 rwrq.ioc_cnt = count;
222 rwrq.ioc_offset = offset;
223 if (nsmb_ioctl(fd, SMBIOC_READ, &rwrq) == -1) {
224 return (-1);
225 }
226 return (rwrq.ioc_cnt);
227 }
228
229 int
230 smb_fh_write(int fd, off64_t offset, size_t count,
231 const char *src)
232 {
233 struct smbioc_rw rwrq;
234
235 bzero(&rwrq, sizeof (rwrq));
236 rwrq.ioc_base = (char *)src;
237 rwrq.ioc_cnt = count;
238 rwrq.ioc_offset = offset;
239 if (nsmb_ioctl(fd, SMBIOC_WRITE, &rwrq) == -1) {
240 return (-1);
241 }
242 return (rwrq.ioc_cnt);
243 }
244
245 /*
246 * Do a TRANSACT_NAMED_PIPE, which is basically just a
247 * pipe write and pipe read, all in one round trip.
248 *
249 * tdlen, tdata describe the data to send.
250 * rdlen, rdata on input describe the receive buffer,
251 * and on output *rdlen is the received length.
252 */
253 int
254 smb_fh_xactnp(int fd,
255 int tdlen, const char *tdata, /* transmit */
256 int *rdlen, char *rdata, /* receive */
257 int *more)
258 {
259 smbioc_xnp_t ioc;
260
261 /* this gets copyin & copyout */
262 bzero(&ioc, sizeof (ioc));
263 ioc.ioc_tdlen = tdlen;
264 ioc.ioc_rdlen = *rdlen;
265 ioc.ioc_more = 0;
266 ioc.ioc_tdata = (char *)tdata;
267 ioc.ioc_rdata = rdata;
268
269 if (nsmb_ioctl(fd, SMBIOC_XACTNP, &ioc) == -1) {
270 *rdlen = 0;
271 return (-1);
272 }
273
274 *rdlen = ioc.ioc_rdlen;
275 *more = ioc.ioc_more;
276
277 return (0);
278 }
|