1 /* 2 * Copyright (c) 2000-2001 Boris Popov 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by Boris Popov. 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 * $FreeBSD$ 33 */ 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/kernel.h> 37 #include <sys/malloc.h> 38 #include <sys/proc.h> 39 #include <sys/lock.h> 40 #include <sys/sysctl.h> 41 #include <sys/socket.h> 42 #include <sys/signalvar.h> 43 #include <sys/mbuf.h> 44 45 #include <sys/iconv.h> 46 47 #include <netsmb/smb.h> 48 #include <netsmb/smb_conn.h> 49 #include <netsmb/smb_rq.h> 50 #include <netsmb/smb_subr.h> 51 52 MALLOC_DEFINE(M_SMBDATA, "SMBDATA", "Misc netsmb data"); 53 MALLOC_DEFINE(M_SMBSTR, "SMBSTR", "netsmb string data"); 54 MALLOC_DEFINE(M_SMBTEMP, "SMBTEMP", "Temp netsmb data"); 55 56 smb_unichar smb_unieol = 0; 57 58 void 59 smb_makescred(struct smb_cred *scred, struct proc *p, struct ucred *cred) 60 { 61 if (p) { 62 scred->scr_p = p; 63 scred->scr_cred = cred ? cred : p->p_ucred; 64 } else { 65 scred->scr_p = NULL; 66 scred->scr_cred = cred ? cred : NULL; 67 } 68 } 69 70 int 71 smb_proc_intr(struct proc *p) 72 { 73 #if __FreeBSD_version < 400009 74 75 if (p && p->p_siglist && 76 (((p->p_siglist & ~p->p_sigmask) & ~p->p_sigignore) & SMB_SIGMASK)) 77 return EINTR; 78 return 0; 79 #else 80 sigset_t tmpset; 81 82 if (p == NULL) 83 return 0; 84 tmpset = p->p_siglist; 85 SIGSETNAND(tmpset, p->p_sigmask); 86 SIGSETNAND(tmpset, p->p_sigignore); 87 if (SIGNOTEMPTY(p->p_siglist) && SMB_SIGMASK(tmpset)) 88 return EINTR; 89 return 0; 90 #endif 91 } 92 93 char * 94 smb_strdup(const char *s) 95 { 96 char *p; 97 int len; 98 99 len = s ? strlen(s) + 1 : 1; 100 p = malloc(len, M_SMBSTR, M_WAITOK); 101 if (s) 102 bcopy(s, p, len); 103 else 104 *p = 0; 105 return p; 106 } 107 108 /* 109 * duplicate string from a user space. 110 */ 111 char * 112 smb_strdupin(char *s, int maxlen) 113 { 114 char *p, bt; 115 int len = 0; 116 117 for (p = s; ;p++) { 118 if (copyin(p, &bt, 1)) 119 return NULL; 120 len++; 121 if (maxlen && len > maxlen) 122 return NULL; 123 if (bt == 0) 124 break; 125 } 126 p = malloc(len, M_SMBSTR, M_WAITOK); 127 copyin(s, p, len); 128 return p; 129 } 130 131 /* 132 * duplicate memory block from a user space. 133 */ 134 void * 135 smb_memdupin(void *umem, int len) 136 { 137 char *p; 138 139 if (len > 8 * 1024) 140 return NULL; 141 p = malloc(len, M_SMBSTR, M_WAITOK); 142 if (copyin(umem, p, len) == 0) 143 return p; 144 free(p, M_SMBSTR); 145 return NULL; 146 } 147 148 /* 149 * duplicate memory block in the kernel space. 150 */ 151 void * 152 smb_memdup(const void *umem, int len) 153 { 154 char *p; 155 156 if (len > 8 * 1024) 157 return NULL; 158 p = malloc(len, M_SMBSTR, M_WAITOK); 159 if (p == NULL) 160 return NULL; 161 bcopy(umem, p, len); 162 return p; 163 } 164 165 void 166 smb_strfree(char *s) 167 { 168 free(s, M_SMBSTR); 169 } 170 171 void 172 smb_memfree(void *s) 173 { 174 free(s, M_SMBSTR); 175 } 176 177 void * 178 smb_zmalloc(unsigned long size, struct malloc_type *type, int flags) 179 { 180 181 return malloc(size, type, flags | M_ZERO); 182 } 183 184 void 185 smb_strtouni(u_int16_t *dst, const char *src) 186 { 187 while (*src) { 188 *dst++ = htoles(*src++); 189 } 190 *dst = 0; 191 } 192 193 #ifdef SMB_SOCKETDATA_DEBUG 194 void 195 m_dumpm(struct mbuf *m) { 196 char *p; 197 int len; 198 printf("d="); 199 while(m) { 200 p=mtod(m,char *); 201 len=m->m_len; 202 printf("(%d)",len); 203 while(len--){ 204 printf("%02x ",((int)*(p++)) & 0xff); 205 } 206 m=m->m_next; 207 }; 208 printf("\n"); 209 } 210 #endif 211 212 int 213 smb_maperror(int eclass, int eno) 214 { 215 if (eclass == 0 && eno == 0) 216 return 0; 217 switch (eclass) { 218 case ERRDOS: 219 switch (eno) { 220 case ERRbadfunc: 221 case ERRbadmcb: 222 case ERRbadenv: 223 case ERRbadformat: 224 case ERRrmuns: 225 return EINVAL; 226 case ERRbadfile: 227 case ERRbadpath: 228 case ERRremcd: 229 case 66: /* nt returns it when share not available */ 230 return ENOENT; 231 case ERRnofids: 232 return EMFILE; 233 case ERRnoaccess: 234 case ERRbadshare: 235 return EACCES; 236 case ERRbadfid: 237 return EBADF; 238 case ERRnomem: 239 return ENOMEM; /* actually remote no mem... */ 240 case ERRbadmem: 241 return EFAULT; 242 case ERRbadaccess: 243 return EACCES; 244 case ERRbaddata: 245 return E2BIG; 246 case ERRbaddrive: 247 case ERRnotready: /* nt */ 248 return ENXIO; 249 case ERRdiffdevice: 250 return EXDEV; 251 case ERRnofiles: 252 return 0; /* eeof ? */ 253 return ETXTBSY; 254 case ERRlock: 255 return EDEADLK; 256 case ERRfilexists: 257 return EEXIST; 258 case 123: /* dunno what is it, but samba maps as noent */ 259 return ENOENT; 260 case 145: /* samba */ 261 return ENOTEMPTY; 262 case 183: 263 return EEXIST; 264 } 265 break; 266 case ERRSRV: 267 switch (eno) { 268 case ERRerror: 269 return EINVAL; 270 case ERRbadpw: 271 return EAUTH; 272 case ERRaccess: 273 return EACCES; 274 case ERRinvnid: 275 return ENETRESET; 276 case ERRinvnetname: 277 SMBERROR("NetBIOS name is invalid\n"); 278 return EAUTH; 279 case 3: /* reserved and returned */ 280 return EIO; 281 case 2239: /* NT: account exists but disabled */ 282 return EPERM; 283 } 284 break; 285 case ERRHRD: 286 switch (eno) { 287 case ERRnowrite: 288 return EROFS; 289 case ERRbadunit: 290 return ENODEV; 291 case ERRnotready: 292 case ERRbadcmd: 293 case ERRdata: 294 return EIO; 295 case ERRbadreq: 296 return EBADRPC; 297 case ERRbadshare: 298 return ETXTBSY; 299 case ERRlock: 300 return EDEADLK; 301 } 302 break; 303 } 304 SMBERROR("Unmapped error %d:%d\n", eclass, eno); 305 return EBADRPC; 306 } 307 308 static int 309 smb_copy_iconv(struct mbchain *mbp, c_caddr_t src, caddr_t dst, int len) 310 { 311 int outlen = len; 312 313 return iconv_conv((struct iconv_drv*)mbp->mb_udata, &src, &len, &dst, &outlen); 314 } 315 316 int 317 smb_put_dmem(struct mbchain *mbp, struct smb_vc *vcp, const char *src, 318 int size, int caseopt) 319 { 320 struct iconv_drv *dp = vcp->vc_toserver; 321 322 if (size == 0) 323 return 0; 324 if (dp == NULL) { 325 return mb_put_mem(mbp, src, size, MB_MSYSTEM); 326 } 327 mbp->mb_copy = smb_copy_iconv; 328 mbp->mb_udata = dp; 329 return mb_put_mem(mbp, src, size, MB_MCUSTOM); 330 } 331 332 int 333 smb_put_dstring(struct mbchain *mbp, struct smb_vc *vcp, const char *src, 334 int caseopt) 335 { 336 int error; 337 338 error = smb_put_dmem(mbp, vcp, src, strlen(src), caseopt); 339 if (error) 340 return error; 341 return mb_put_uint8(mbp, 0); 342 } 343 344 int 345 smb_put_asunistring(struct smb_rq *rqp, const char *src) 346 { 347 struct mbchain *mbp = &rqp->sr_rq; 348 struct iconv_drv *dp = rqp->sr_vc->vc_toserver; 349 u_char c; 350 int error; 351 352 while (*src) { 353 iconv_convmem(dp, &c, src++, 1); 354 error = mb_put_uint16le(mbp, c); 355 if (error) 356 return error; 357 } 358 return mb_put_uint16le(mbp, 0); 359 } 360