1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2000-2001 Boris Popov
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/endian.h>
33 #include <sys/kernel.h>
34 #include <sys/malloc.h>
35 #include <sys/proc.h>
36 #include <sys/lock.h>
37 #include <sys/sysctl.h>
38 #include <sys/socket.h>
39 #include <sys/signalvar.h>
40 #include <sys/mbuf.h>
41
42 #include <sys/iconv.h>
43
44 #include <netsmb/smb.h>
45 #include <netsmb/smb_conn.h>
46 #include <netsmb/smb_rq.h>
47 #include <netsmb/smb_subr.h>
48
49 static MALLOC_DEFINE(M_SMBDATA, "SMBDATA", "Misc netsmb data");
50 static MALLOC_DEFINE(M_SMBSTR, "SMBSTR", "netsmb string data");
51 MALLOC_DEFINE(M_SMBTEMP, "SMBTEMP", "Temp netsmb data");
52
53 smb_unichar smb_unieol = 0;
54
55 void
smb_makescred(struct smb_cred * scred,struct thread * td,struct ucred * cred)56 smb_makescred(struct smb_cred *scred, struct thread *td, struct ucred *cred)
57 {
58 if (td) {
59 scred->scr_td = td;
60 scred->scr_cred = cred ? cred : td->td_ucred;
61 } else {
62 scred->scr_td = NULL;
63 scred->scr_cred = cred ? cred : NULL;
64 }
65 }
66
67 int
smb_td_intr(struct thread * td)68 smb_td_intr(struct thread *td)
69 {
70 struct proc *p;
71 sigset_t tmpset;
72
73 if (td == NULL)
74 return 0;
75
76 p = td->td_proc;
77 PROC_LOCK(p);
78 tmpset = p->p_siglist;
79 SIGSETOR(tmpset, td->td_siglist);
80 SIGSETNAND(tmpset, td->td_sigmask);
81 mtx_lock(&p->p_sigacts->ps_mtx);
82 SIGSETNAND(tmpset, p->p_sigacts->ps_sigignore);
83 mtx_unlock(&p->p_sigacts->ps_mtx);
84 if (SIGNOTEMPTY(td->td_siglist) && SMB_SIGMASK(tmpset)) {
85 PROC_UNLOCK(p);
86 return EINTR;
87 }
88 PROC_UNLOCK(p);
89 return 0;
90 }
91
92 char *
smb_strdup(const char * s)93 smb_strdup(const char *s)
94 {
95 char *p;
96 size_t len;
97
98 len = s ? strlen(s) + 1 : 1;
99 p = malloc(len, M_SMBSTR, M_WAITOK);
100 if (s)
101 bcopy(s, p, len);
102 else
103 *p = 0;
104 return p;
105 }
106
107 /*
108 * duplicate string from a user space.
109 */
110 char *
smb_strdupin(char * s,size_t maxlen)111 smb_strdupin(char *s, size_t maxlen)
112 {
113 char *p;
114 int error;
115
116 p = malloc(maxlen + 1, M_SMBSTR, M_WAITOK);
117 error = copyinstr(s, p, maxlen + 1, NULL);
118 if (error) {
119 free(p, M_SMBSTR);
120 return (NULL);
121 }
122 return p;
123 }
124
125 /*
126 * duplicate memory block from a user space.
127 */
128 void *
smb_memdupin(void * umem,size_t len)129 smb_memdupin(void *umem, size_t len)
130 {
131 char *p;
132
133 if (len > 8 * 1024)
134 return NULL;
135 p = malloc(len, M_SMBSTR, M_WAITOK);
136 if (copyin(umem, p, len) == 0)
137 return p;
138 free(p, M_SMBSTR);
139 return NULL;
140 }
141
142 /*
143 * duplicate memory block in the kernel space.
144 */
145 void *
smb_memdup(const void * umem,int len)146 smb_memdup(const void *umem, int len)
147 {
148 char *p;
149
150 if (len > 8 * 1024)
151 return NULL;
152 p = malloc(len, M_SMBSTR, M_WAITOK);
153 bcopy(umem, p, len);
154 return p;
155 }
156
157 void
smb_strfree(char * s)158 smb_strfree(char *s)
159 {
160 free(s, M_SMBSTR);
161 }
162
163 void
smb_memfree(void * s)164 smb_memfree(void *s)
165 {
166 free(s, M_SMBSTR);
167 }
168
169 void *
smb_zmalloc(size_t size,struct malloc_type * type,int flags)170 smb_zmalloc(size_t size, struct malloc_type *type, int flags)
171 {
172
173 return malloc(size, type, flags | M_ZERO);
174 }
175
176 void
smb_strtouni(u_int16_t * dst,const char * src)177 smb_strtouni(u_int16_t *dst, const char *src)
178 {
179 while (*src) {
180 *dst++ = htole16(*src++);
181 }
182 *dst = 0;
183 }
184
185 #ifdef SMB_SOCKETDATA_DEBUG
186 void
m_dumpm(struct mbuf * m)187 m_dumpm(struct mbuf *m) {
188 char *p;
189 size_t len;
190 printf("d=");
191 while(m) {
192 p=mtod(m,char *);
193 len=m->m_len;
194 printf("(%zu)",len);
195 while(len--){
196 printf("%02x ",((int)*(p++)) & 0xff);
197 }
198 m=m->m_next;
199 }
200 printf("\n");
201 }
202 #endif
203
204 int
smb_maperror(int eclass,int eno)205 smb_maperror(int eclass, int eno)
206 {
207 if (eclass == 0 && eno == 0)
208 return 0;
209 switch (eclass) {
210 case ERRDOS:
211 switch (eno) {
212 case ERRbadfunc:
213 case ERRbadmcb:
214 case ERRbadenv:
215 case ERRbadformat:
216 case ERRrmuns:
217 return EINVAL;
218 case ERRbadfile:
219 case ERRbadpath:
220 case ERRremcd:
221 case 66: /* nt returns it when share not available */
222 case 67: /* observed from nt4sp6 when sharename wrong */
223 return ENOENT;
224 case ERRnofids:
225 return EMFILE;
226 case ERRnoaccess:
227 case ERRbadshare:
228 return EACCES;
229 case ERRbadfid:
230 return EBADF;
231 case ERRnomem:
232 return ENOMEM; /* actually remote no mem... */
233 case ERRbadmem:
234 return EFAULT;
235 case ERRbadaccess:
236 return EACCES;
237 case ERRbaddata:
238 return E2BIG;
239 case ERRbaddrive:
240 case ERRnotready: /* nt */
241 return ENXIO;
242 case ERRdiffdevice:
243 return EXDEV;
244 case ERRnofiles:
245 return 0; /* eeof ? */
246 return ETXTBSY;
247 case ERRlock:
248 return EDEADLK;
249 case ERRfilexists:
250 return EEXIST;
251 case 123: /* dunno what is it, but samba maps as noent */
252 return ENOENT;
253 case 145: /* samba */
254 return ENOTEMPTY;
255 case ERRnotlocked:
256 return 0; /* file become unlocked */
257 case 183:
258 return EEXIST;
259 case ERRquota:
260 return EDQUOT;
261 }
262 break;
263 case ERRSRV:
264 switch (eno) {
265 case ERRerror:
266 return EINVAL;
267 case ERRbadpw:
268 case ERRpasswordExpired:
269 return EAUTH;
270 case ERRaccess:
271 return EACCES;
272 case ERRinvnid:
273 return ENETRESET;
274 case ERRinvnetname:
275 SMBERROR("NetBIOS name is invalid\n");
276 return EAUTH;
277 case 3: /* reserved and returned */
278 return EIO;
279 case ERRaccountExpired:
280 case ERRbadClient:
281 case ERRbadLogonTime:
282 return EPERM;
283 case ERRnosupport:
284 return EBADRPC;
285 }
286 break;
287 case ERRHRD:
288 switch (eno) {
289 case ERRnowrite:
290 return EROFS;
291 case ERRbadunit:
292 return ENODEV;
293 case ERRnotready:
294 case ERRbadcmd:
295 case ERRdata:
296 return EIO;
297 case ERRbadreq:
298 return EBADRPC;
299 case ERRbadshare:
300 return ETXTBSY;
301 case ERRlock:
302 return EDEADLK;
303 }
304 break;
305 }
306 SMBERROR("Unmapped error %d:%d\n", eclass, eno);
307 return EBADRPC;
308 }
309
310 static int
smb_copy_iconv(struct mbchain * mbp,c_caddr_t src,caddr_t dst,size_t * srclen,size_t * dstlen)311 smb_copy_iconv(struct mbchain *mbp, c_caddr_t src, caddr_t dst,
312 size_t *srclen, size_t *dstlen)
313 {
314 int error;
315 size_t inlen = *srclen, outlen = *dstlen;
316
317 error = iconv_conv((struct iconv_drv*)mbp->mb_udata, &src, &inlen,
318 &dst, &outlen);
319 if (inlen != *srclen || outlen != *dstlen) {
320 *srclen -= inlen;
321 *dstlen -= outlen;
322 return 0;
323 } else
324 return error;
325 }
326
327 int
smb_put_dmem(struct mbchain * mbp,struct smb_vc * vcp,const char * src,size_t size,int caseopt)328 smb_put_dmem(struct mbchain *mbp, struct smb_vc *vcp, const char *src,
329 size_t size, int caseopt)
330 {
331 struct iconv_drv *dp = vcp->vc_toserver;
332
333 if (size == 0)
334 return 0;
335 if (dp == NULL) {
336 return mb_put_mem(mbp, src, size, MB_MSYSTEM);
337 }
338 mbp->mb_copy = smb_copy_iconv;
339 mbp->mb_udata = dp;
340 if (SMB_UNICODE_STRINGS(vcp))
341 mb_put_padbyte(mbp);
342 return mb_put_mem(mbp, src, size, MB_MCUSTOM);
343 }
344
345 int
smb_put_dstring(struct mbchain * mbp,struct smb_vc * vcp,const char * src,int caseopt)346 smb_put_dstring(struct mbchain *mbp, struct smb_vc *vcp, const char *src,
347 int caseopt)
348 {
349 int error;
350
351 error = smb_put_dmem(mbp, vcp, src, strlen(src), caseopt);
352 if (error)
353 return error;
354 if (SMB_UNICODE_STRINGS(vcp))
355 return mb_put_uint16le(mbp, 0);
356 return mb_put_uint8(mbp, 0);
357 }
358
359 int
smb_put_asunistring(struct smb_rq * rqp,const char * src)360 smb_put_asunistring(struct smb_rq *rqp, const char *src)
361 {
362 struct mbchain *mbp = &rqp->sr_rq;
363 struct iconv_drv *dp = rqp->sr_vc->vc_toserver;
364 u_char c;
365 int error;
366
367 while (*src) {
368 iconv_convmem(dp, &c, src++, 1);
369 error = mb_put_uint16le(mbp, c);
370 if (error)
371 return error;
372 }
373 return mb_put_uint16le(mbp, 0);
374 }
375