libtinysmb/smb_devoptab.c

   1 /****************************************************************************
   2  * TinySMB
   3  * Nintendo Wii/GameCube SMB implementation
   4  *
   5  * SMB devoptab
   6  ****************************************************************************/
   7
   8 #include <malloc.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11 #include <errno.h>
  12 #include <string.h>
  13 #include <sys/iosupport.h>
  14 #include <network.h>
  15 #include <ogcsys.h>
  16 #include <ogc/lwp_watchdog.h>
  17 #include <ogc/mutex.h>
  18
  19 #include "smb.h"
  20
  21 static mutex_t _SMB_mutex=LWP_MUTEX_NULL;
  22
  23 static inline void _SMB_lock()
  24 {
  25         if(_SMB_mutex!=LWP_MUTEX_NULL) LWP_MutexLock(_SMB_mutex);
  26 }
  27
  28 static inline void _SMB_unlock()
  29 {
  30         if(_SMB_mutex!=LWP_MUTEX_NULL) LWP_MutexUnlock(_SMB_mutex);
  31 }
  32
  33 typedef struct
  34 {
  35         SMBFILE handle;
  36         off_t offset;
  37         off_t len;
  38         char filename[SMB_MAXPATH];
  39         unsigned short access;
  40         int env;
  41 } SMBFILESTRUCT;
  42
  43 typedef struct
  44 {
  45         SMBDIRENTRY smbdir;
  46         int env;
  47 } SMBDIRSTATESTRUCT;
  48
  49 static bool FirstInit=true;
  50 #define MAX_SMB_MOUNTED 5
  51
  52 ///////////////////////////////////////////
  53 //      CACHE FUNCTION DEFINITIONS       //
  54 ///////////////////////////////////////////
  55 #define SMB_CACHE_FREE 0xFFFFFFFF
  56 #define SMB_READ_BUFFERSIZE             7236
  57 #define SMB_WRITE_BUFFERSIZE    7236
  58
  59 typedef struct
  60 {
  61         off_t offset;
  62         u32 last_used;
  63         SMBFILESTRUCT *file;
  64         void *ptr;
  65 } smb_cache_page;
  66
  67 typedef struct
  68 {
  69         off_t used;
  70         off_t len;
  71         SMBFILESTRUCT *file;
  72         void *ptr;
  73 } smb_write_cache;
  74
  75 void DestroySMBReadAheadCache(char *name);
  76 void SMBEnableReadAhead(char *name, u32 pages);
  77 int ReadSMBFromCache(void *buf, int len, SMBFILESTRUCT *file);
  78
  79 static lwp_t main_thread;
  80 static bool end_cache_thread = true;
  81 ///////////////////////////////////////////
  82 //    END CACHE FUNCTION DEFINITIONS     //
  83 ///////////////////////////////////////////
  84
  85 // SMB Enviroment
  86 typedef struct
  87 {
  88         char *name;
  89         int pos;
  90         devoptab_t *devoptab;
  91
  92         SMBCONN smbconn;
  93         u8 SMBCONNECTED ;
  94
  95         char currentpath[SMB_MAXPATH];
  96         bool first_item_dir ;
  97         bool diropen_root;
  98
  99         smb_write_cache SMBWriteCache;
 100         smb_cache_page *SMBReadAheadCache;
 101         u32 SMB_RA_pages;
 102
 103 } smb_env;
 104
 105 static smb_env SMBEnv[MAX_SMB_MOUNTED];
 106
 107
 108 ///////////////////////////////////////////
 109 //         CACHE FUNCTIONS              //
 110 ///////////////////////////////////////////
 111
 112 smb_env* FindSMBEnv(const char *name)
 113 {
 114         int i;
 115
 116         for(i=0;i<MAX_SMB_MOUNTED ;i++)
 117         {
 118                 if(SMBEnv[i].SMBCONNECTED && strcmp(name,SMBEnv[i].name)==0)
 119                 {
 120                         return &SMBEnv[i];
 121                 }
 122         }
 123         return NULL;
 124 }
 125
 126 int FlushWriteSMBCache(char *name)
 127 {
 128         smb_env *env;
 129         env=FindSMBEnv(name);
 130         if(env==NULL) return -1;
 131         _SMB_lock();
 132         if (env->SMBWriteCache.file == NULL || env->SMBWriteCache.len == 0)
 133         {
 134                 _SMB_unlock();
 135                 return 0;
 136         }
 137
 138         int written = 0;
 139
 140         written = SMB_WriteFile(env->SMBWriteCache.ptr, env->SMBWriteCache.len,
 141                         env->SMBWriteCache.file->offset, env->SMBWriteCache.file->handle);
 142
 143         if (written <= 0)
 144         {
 145                 env->SMBWriteCache.used = 0;
 146                 env->SMBWriteCache.len = 0;
 147                 env->SMBWriteCache.file = NULL;
 148                 _SMB_unlock();
 149                 return -1;
 150         }
 151         env->SMBWriteCache.file->offset += written;
 152         if (env->SMBWriteCache.file->offset > env->SMBWriteCache.file->len)
 153                 env->SMBWriteCache.file->len = env->SMBWriteCache.file->offset;
 154         env->SMBWriteCache.used = 0;
 155         env->SMBWriteCache.len = 0;
 156         env->SMBWriteCache.file = NULL;
 157         _SMB_unlock();
 158         return 0;
 159 }
 160
 161 void DestroySMBReadAheadCache(char *name)
 162 {
 163         smb_env *env;
 164         env=FindSMBEnv(name);
 165         if(env==NULL) return ;
 166
 167         int i;
 168         if (env->SMBReadAheadCache != NULL)
 169         {
 170                 for (i = 0; i < env->SMB_RA_pages; i++)
 171                 {
 172                         if(env->SMBReadAheadCache[i].ptr)
 173                                 free(env->SMBReadAheadCache[i].ptr);
 174                 }
 175                 free(env->SMBReadAheadCache);
 176                 env->SMBReadAheadCache = NULL;
 177                 env->SMB_RA_pages = 0;
 178
 179                 //end_cache_thread = true;
 180         }
 181         FlushWriteSMBCache(env->name);
 182
 183         if(env->SMBWriteCache.ptr)
 184                 free(env->SMBWriteCache.ptr);
 185
 186         env->SMBWriteCache.used = 0;
 187         env->SMBWriteCache.len = 0;
 188         env->SMBWriteCache.file = NULL;
 189         env->SMBWriteCache.ptr = NULL;
 190 }
 191
 192 static void *process_cache_thread(void *ptr)
 193 {
 194         int i;
 195         while (1)
 196         {
 197                 //_SMB_lock();
 198                 for(i=0;i<MAX_SMB_MOUNTED ;i++)
 199                 {
 200                         if(SMBEnv[i].SMBCONNECTED)
 201                         {
 202                                 if (SMBEnv[i].SMBWriteCache.used > 0)
 203                                 {
 204                                         if (ticks_to_millisecs(gettime())-ticks_to_millisecs(SMBEnv[i].SMBWriteCache.used) > 500)
 205                                         {
 206                                                 FlushWriteSMBCache(SMBEnv[i].name);
 207                                         }
 208                                 }
 209                         }
 210                 }
 211                 //_SMB_unlock();
 212                 usleep(10000);
 213                 if (end_cache_thread) break;
 214         }
 215
 216         LWP_JoinThread(main_thread, NULL);
 217         return NULL;
 218 }
 219
 220 void SMBEnableReadAhead(char *name, u32 pages)
 221 {
 222         int i, j;
 223
 224         smb_env *env;
 225         env=FindSMBEnv(name);
 226         if(env==NULL) return;
 227
 228         DestroySMBReadAheadCache(name);
 229
 230         if (pages == 0)
 231                 return;
 232
 233         //only 1 page for write
 234         env->SMBWriteCache.ptr = memalign(32, SMB_WRITE_BUFFERSIZE);
 235         env->SMBWriteCache.used = 0;
 236         env->SMBWriteCache.len = 0;
 237         env->SMBWriteCache.file = NULL;
 238
 239         env->SMB_RA_pages = pages;
 240         env->SMBReadAheadCache = (smb_cache_page *) malloc(sizeof(smb_cache_page) * env->SMB_RA_pages);
 241         if (env->SMBReadAheadCache == NULL)
 242                 return;
 243         for (i = 0; i < env->SMB_RA_pages; i++)
 244         {
 245                 env->SMBReadAheadCache[i].offset = SMB_CACHE_FREE;
 246                 env->SMBReadAheadCache[i].last_used = 0;
 247                 env->SMBReadAheadCache[i].file = NULL;
 248                 env->SMBReadAheadCache[i].ptr = memalign(32, SMB_READ_BUFFERSIZE);
 249                 if (env->SMBReadAheadCache[i].ptr == NULL)
 250                 {
 251                         for (j = i - 1; j >= 0; j--)
 252                                 if (env->SMBReadAheadCache[j].ptr)
 253                                         free(env->SMBReadAheadCache[j].ptr);
 254                         free(env->SMBReadAheadCache);
 255                         env->SMBReadAheadCache = NULL;
 256                         free(env->SMBWriteCache.ptr);
 257                         return;
 258                 }
 259                 memset(env->SMBReadAheadCache[i].ptr, 0, SMB_READ_BUFFERSIZE);
 260         }
 261
 262 }
 263
 264 // clear cache from file (clear if you write to the file)
 265 void ClearSMBFileCache(SMBFILESTRUCT *file)
 266 {
 267         int i,j;
 268         j=file->env;
 269         for (i = 0; i < SMBEnv[j].SMB_RA_pages; i++)
 270         {
 271                 if (SMBEnv[j].SMBReadAheadCache[i].offset != SMB_CACHE_FREE)
 272                 {
 273                         if (strcmp(SMBEnv[j].SMBReadAheadCache[i].file->filename, file->filename)==0)
 274                         {
 275                                 SMBEnv[j].SMBReadAheadCache[i].offset = SMB_CACHE_FREE;
 276                                 SMBEnv[j].SMBReadAheadCache[i].last_used = 0;
 277                                 SMBEnv[j].SMBReadAheadCache[i].file = NULL;
 278
 279                                 memset(SMBEnv[j].SMBReadAheadCache[i].ptr, 0, SMB_READ_BUFFERSIZE);
 280                         }
 281                 }
 282         }
 283 }
 284
 285 int ReadSMBFromCache(void *buf, int len, SMBFILESTRUCT *file)
 286 {
 287         int retval;
 288         int i,j, leastUsed, rest;
 289         u32 new_offset;
 290         j=file->env;
 291         _SMB_lock();
 292         if (SMBEnv[j].SMBReadAheadCache == NULL)
 293         {
 294                 if (SMB_ReadFile(buf, len, file->offset, file->handle) <= 0)
 295                 {
 296                         _SMB_unlock();
 297                         return -1;
 298                 }
 299                 _SMB_unlock();
 300                 return 0;
 301         }
 302         new_offset = file->offset;
 303         rest = len;
 304         leastUsed = 0;
 305         for (i = 0; i < SMBEnv[j].SMB_RA_pages; i++)
 306         {
 307                 if (SMBEnv[j].SMBReadAheadCache[i].file == file)
 308                 {
 309                         if ((file->offset >= SMBEnv[j].SMBReadAheadCache[i].offset) &&
 310                                 (file->offset < (SMBEnv[j].SMBReadAheadCache[i].offset + SMB_READ_BUFFERSIZE)))
 311                         {
 312                                 if ((file->offset + len) <= (SMBEnv[j].SMBReadAheadCache[i].offset + SMB_READ_BUFFERSIZE))
 313                                 {
 314                                         SMBEnv[j].SMBReadAheadCache[i].last_used = gettime();
 315                                         memcpy(buf, SMBEnv[j].SMBReadAheadCache[i].ptr + (file->offset - SMBEnv[j].SMBReadAheadCache[i].offset), len);
 316                                         _SMB_unlock();
 317                                         return 0;
 318                                 }
 319                                 else
 320                                 {
 321                                         int buffer_used;
 322                                         SMBEnv[j].SMBReadAheadCache[i].last_used = gettime();
 323                                         buffer_used = (SMBEnv[j].SMBReadAheadCache[i].offset + SMB_READ_BUFFERSIZE) - file->offset;
 324                                         memcpy(buf, SMBEnv[j].SMBReadAheadCache[i].ptr + (file->offset - SMBEnv[j].SMBReadAheadCache[i].offset), buffer_used);
 325                                         buf += buffer_used;
 326                                         rest = len - buffer_used;
 327                                         new_offset = SMBEnv[j].SMBReadAheadCache[i].offset + SMB_READ_BUFFERSIZE;
 328                                         i++;
 329                                         break;
 330                                 }
 331
 332                         }
 333                 }
 334                 if ((SMBEnv[j].SMBReadAheadCache[i].last_used < SMBEnv[j].SMBReadAheadCache[leastUsed].last_used))
 335                         leastUsed = i;
 336         }
 337
 338         for (; i < SMBEnv[j].SMB_RA_pages; i++)
 339         {
 340                 if ((SMBEnv[j].SMBReadAheadCache[i].last_used < SMBEnv[j].SMBReadAheadCache[leastUsed].last_used))
 341                         leastUsed = i;
 342         }
 343
 344         retval = SMB_ReadFile(SMBEnv[j].SMBReadAheadCache[leastUsed].ptr, SMB_READ_BUFFERSIZE, new_offset, file->handle);
 345
 346         if (retval <= 0)
 347         {
 348                 SMBEnv[j].SMBReadAheadCache[leastUsed].offset = SMB_CACHE_FREE;
 349                 SMBEnv[j].SMBReadAheadCache[leastUsed].last_used = 0;
 350                 SMBEnv[j].SMBReadAheadCache[leastUsed].file = NULL;
 351                 _SMB_unlock();
 352                 return -1;
 353         }
 354
 355         SMBEnv[j].SMBReadAheadCache[leastUsed].offset = new_offset;
 356         SMBEnv[j].SMBReadAheadCache[leastUsed].last_used = gettime();
 357         SMBEnv[j].SMBReadAheadCache[leastUsed].file = file;
 358         memcpy(buf, SMBEnv[j].SMBReadAheadCache[leastUsed].ptr, rest);
 359         _SMB_unlock();
 360         return 0;
 361 }
 362
 363 int WriteSMBUsingCache(const char *buf, int len, SMBFILESTRUCT *file)
 364 {
 365         if (file == NULL || buf == NULL)
 366                 return -1;
 367
 368         int j,ret = len;
 369         _SMB_lock();
 370         j=file->env;
 371         if (SMBEnv[j].SMBWriteCache.file != NULL)
 372         {
 373                 if (strcmp(SMBEnv[j].SMBWriteCache.file->filename, file->filename) != 0)
 374                 {
 375                         //Flush current buffer
 376                         if (FlushWriteSMBCache(SMBEnv[j].name) < 0)
 377                         {
 378                                 _SMB_unlock();
 379                                 return -1;
 380                         }
 381                 }
 382         }
 383         SMBEnv[j].SMBWriteCache.file = file;
 384
 385         if (SMBEnv[j].SMBWriteCache.len + len >= SMB_WRITE_BUFFERSIZE)
 386         {
 387                 void *send_buf;
 388                 int rest = 0, written = 0;
 389                 send_buf = memalign(32, SMB_WRITE_BUFFERSIZE);
 390                 if (SMBEnv[j].SMBWriteCache.len > 0)
 391                         memcpy(send_buf, SMBEnv[j].SMBWriteCache.ptr, SMBEnv[j].SMBWriteCache.len);
 392 loop:
 393                 rest = SMB_WRITE_BUFFERSIZE - SMBEnv[j].SMBWriteCache.len;
 394                 memcpy(send_buf + SMBEnv[j].SMBWriteCache.len, buf, rest);
 395                 written = SMB_WriteFile(send_buf, SMB_WRITE_BUFFERSIZE,
 396                                 SMBEnv[j].SMBWriteCache.file->offset, SMBEnv[j].SMBWriteCache.file->handle);
 397                 free(send_buf);
 398                 if (written <= 0)
 399                 {
 400                         SMBEnv[j].SMBWriteCache.used = 0;
 401                         SMBEnv[j].SMBWriteCache.len = 0;
 402                         SMBEnv[j].SMBWriteCache.file = NULL;
 403                         _SMB_unlock();
 404                         return -1;
 405                 }
 406                 file->offset += written;
 407                 if (file->offset > file->len)
 408                         file->len = file->offset;
 409
 410                 buf = buf + rest;
 411                 len = SMBEnv[j].SMBWriteCache.len + len - SMB_WRITE_BUFFERSIZE;
 412
 413                 SMBEnv[j].SMBWriteCache.used = gettime();
 414                 SMBEnv[j].SMBWriteCache.len = 0;
 415
 416                 if(len>=SMB_WRITE_BUFFERSIZE) goto loop;
 417         }
 418         if (len > 0)
 419         {
 420                 memcpy(SMBEnv[j].SMBWriteCache.ptr + SMBEnv[j].SMBWriteCache.len, buf, len);
 421                 SMBEnv[j].SMBWriteCache.len += len;
 422         }
 423         _SMB_unlock();
 424         return ret;
 425 }
 426
 427 ///////////////////////////////////////////
 428 //         END CACHE FUNCTIONS           //
 429 ///////////////////////////////////////////
 430
 431 static char *smb_absolute_path_no_device(const char *srcpath, char *destpath, int env)
 432 {
 433         if (strchr(srcpath, ':') != NULL)
 434         {
 435                 srcpath = strchr(srcpath, ':') + 1;
 436         }
 437         if (strchr(srcpath, ':') != NULL)
 438         {
 439                 return NULL;
 440         }
 441
 442         if (srcpath[0] != '\\' && srcpath[0] != '/')
 443         {
 444                 strcpy(destpath, SMBEnv[env].currentpath);
 445                 strcat(destpath, srcpath);
 446         }
 447         else
 448         {
 449                 strcpy(destpath, srcpath);
 450         }
 451         int i, l;
 452         l = strlen(destpath);
 453         for (i = 0; i < l; i++)
 454                 if (destpath[i] == '/')
 455                         destpath[i] = '\\';
 456
 457         return destpath;
 458 }
 459
 460 char *ExtractDevice(const char *path, char *device)
 461 {
 462         int i,l;
 463         l=strlen(path);
 464
 465         for(i=0;i<l && path[i]!='\0' && path[i]!=':' && i < 20;i++)
 466                 device[i]=path[i];
 467         if(path[i]!=':')device[0]='\0';
 468         else device[i]='\0';
 469         return device;
 470 }
 471
 472 //FILE IO
 473 static int __smb_open(struct _reent *r, void *fileStruct, const char *path, int flags, int mode)
 474 {
 475         SMBFILESTRUCT *file = (SMBFILESTRUCT*) fileStruct;
 476
 477
 478         char fixedpath[SMB_MAXPATH];
 479
 480         smb_env *env;
 481
 482         ExtractDevice(path,fixedpath);
 483         if(fixedpath[0]=='\0')
 484         {
 485                 getcwd(fixedpath,SMB_MAXPATH);
 486                 ExtractDevice(fixedpath,fixedpath);
 487         }
 488         env=FindSMBEnv(fixedpath);
 489         file->env=env->pos;
 490
 491         if (!env->SMBCONNECTED)
 492         {
 493                 r->_errno = ENODEV;
 494                 return -1;
 495         }
 496
 497         if (smb_absolute_path_no_device(path, fixedpath, file->env) == NULL)
 498         {
 499                 r->_errno = EINVAL;
 500                 return -1;
 501         }
 502
 503         SMBDIRENTRY dentry;
 504         bool fileExists = true;
 505         _SMB_lock();
 506         if (SMB_PathInfo(fixedpath, &dentry, env->smbconn) != SMB_SUCCESS)
 507                 fileExists = false;
 508
 509         _SMB_unlock();
 510
 511         // Determine which mode the file is open for
 512         u8 smb_mode;
 513         unsigned short access;
 514         if ((flags & 0x03) == O_RDONLY)
 515         {
 516                 // Open the file for read-only access
 517                 smb_mode = SMB_OF_OPEN;
 518                 access = SMB_OPEN_READING;
 519         }
 520         else if ((flags & 0x03) == O_WRONLY)
 521         {
 522                 // Open file for write only access
 523                 if (fileExists)
 524                         smb_mode = SMB_OF_OPEN;
 525                 else
 526                         smb_mode = SMB_OF_CREATE;
 527                 access = SMB_OPEN_WRITING;
 528         }
 529         else if ((flags & 0x03) == O_RDWR)
 530         {
 531                 // Open file for read/write access
 532                 access = SMB_OPEN_READWRITE;
 533                 if (fileExists)
 534                         smb_mode = SMB_OF_OPEN;
 535                 else
 536                         smb_mode = SMB_OF_CREATE;
 537         }
 538         else
 539         {
 540                 r->_errno = EACCES;
 541                 return -1;
 542         }
 543
 544         if ((flags & O_CREAT) && !fileExists)
 545                 smb_mode = SMB_OF_CREATE;
 546         if (!(flags & O_APPEND) && fileExists && ((flags & 0x03) != O_RDONLY))
 547                 smb_mode = SMB_OF_TRUNCATE;
 548
 549         _SMB_lock();
 550         file->handle = SMB_OpenFile(fixedpath, access, smb_mode, env->smbconn);
 551         _SMB_unlock();
 552         if (!file->handle)
 553         {
 554                 r->_errno = ENOENT;
 555                 return -1;
 556         }
 557
 558         file->len = 0;
 559         if (fileExists)
 560                 file->len = dentry.size;
 561
 562         if (flags & O_APPEND)
 563                 file->offset = file->len;
 564         else
 565                 file->offset = 0;
 566
 567         file->access=access;
 568
 569         strcpy(file->filename, fixedpath);
 570         return 0;
 571 }
 572
 573 static off_t __smb_seek(struct _reent *r, int fd, off_t pos, int dir)
 574 {
 575         SMBFILESTRUCT *file = (SMBFILESTRUCT*) fd;
 576         off_t position;
 577
 578         if (file == NULL)
 579         {
 580                 r->_errno = EBADF;
 581                 return -1;
 582         }
 583
 584         switch (dir)
 585         {
 586         case SEEK_SET:
 587                 position = pos;
 588                 break;
 589         case SEEK_CUR:
 590                 position = file->offset + pos;
 591                 break;
 592         case SEEK_END:
 593                 position = file->len + pos;
 594                 break;
 595         default:
 596                 r->_errno = EINVAL;
 597                 return -1;
 598         }
 599
 600         if (((pos > 0) && (position < 0)) || (position > file->len))
 601         {
 602                 r->_errno = EOVERFLOW;
 603                 return -1;
 604         }
 605         if (position < 0)
 606         {
 607                 r->_errno = EINVAL;
 608                 return -1;
 609         }
 610
 611         // Save position
 612         file->offset = position;
 613         return position;
 614 }
 615
 616 static ssize_t __smb_read(struct _reent *r, int fd, char *ptr, size_t len)
 617 {
 618         SMBFILESTRUCT *file = (SMBFILESTRUCT*) fd;
 619
 620         if (file == NULL)
 621         {
 622                 r->_errno = EBADF;
 623                 return -1;
 624         }
 625
 626         // Don't try to read if the read pointer is past the end of file
 627         if (file->offset > file->len)
 628         {
 629                 r->_errno = EOVERFLOW;
 630                 return -1;
 631         }
 632
 633         // Don't read past end of file
 634         if (len + file->offset > file->len)
 635         {
 636                 len = file->len - file->offset;
 637                 if (len < 0)
 638                         len = 0;
 639                 r->_errno = EOVERFLOW;
 640
 641                 if (len == 0)
 642                         return 0;
 643         }
 644
 645         // Short circuit cases where len is 0 (or less)
 646         if (len <= 0)
 647         {
 648                 r->_errno = EOVERFLOW;
 649                 return -1;
 650         }
 651
 652         int cnt_retry=2;
 653         retry_read:
 654         if (ReadSMBFromCache(ptr, len, file) < 0)
 655         {
 656                 retry_reconnect:
 657                 cnt_retry--;
 658                 if(cnt_retry>=0)
 659                 {
 660                         _SMB_lock();
 661                         if(CheckSMBConnection(SMBEnv[file->env].name))
 662                         {
 663                                 ClearSMBFileCache(file);
 664                                 file->handle = SMB_OpenFile(file->filename, file->access, SMB_OF_OPEN, SMBEnv[file->env].smbconn);
 665                                 if (!file->handle)
 666                                 {
 667                                         r->_errno = ENOENT;
 668                                         _SMB_unlock();
 669                                         return -1;
 670                                 }
 671                                 _SMB_unlock();
 672                                 goto retry_read;
 673                         }
 674                         _SMB_unlock();
 675                         usleep(50000);
 676                         goto retry_reconnect;
 677                 }
 678                 r->_errno = EOVERFLOW;
 679                 return -1;
 680         }
 681         file->offset += len;
 682
 683         return len;
 684
 685 }
 686
 687 static ssize_t __smb_write(struct _reent *r, int fd, const char *ptr, size_t len)
 688 {
 689         SMBFILESTRUCT *file = (SMBFILESTRUCT*) fd;
 690         int written;
 691         if (file == NULL)
 692         {
 693                 r->_errno = EBADF;
 694                 return -1;
 695         }
 696
 697         // Don't try to write if the pointer is past the end of file
 698         if (file->offset > file->len)
 699         {
 700                 r->_errno = EOVERFLOW;
 701                 return -1;
 702         }
 703
 704         // Short circuit cases where len is 0 (or less)
 705         if (len <= 0)
 706         {
 707                 r->_errno = EOVERFLOW;
 708                 return -1;
 709         }
 710
 711         ClearSMBFileCache(file);
 712         written = WriteSMBUsingCache(ptr, len, file);
 713         if (written <= 0)
 714         {
 715                 r->_errno = EIO;
 716                 return -1;
 717         }
 718
 719         return written;
 720 }
 721
 722 static int __smb_close(struct _reent *r, int fd)
 723 {
 724         SMBFILESTRUCT *file = (SMBFILESTRUCT*) fd;
 725         int j;
 726         j=file->env;
 727         _SMB_lock();
 728         if (SMBEnv[j].SMBWriteCache.file == file)
 729         {
 730                 FlushWriteSMBCache(SMBEnv[j].name);
 731         }
 732         ClearSMBFileCache(file);
 733         SMB_CloseFile(file->handle);
 734         _SMB_unlock();
 735         file->len = 0;
 736         file->offset = 0;
 737         file->filename[0] = '\0';
 738
 739         return 0;
 740 }
 741
 742 static int __smb_chdir(struct _reent *r, const char *path)
 743 {
 744         char path_absolute[SMB_MAXPATH];
 745
 746         SMBDIRENTRY dentry;
 747         int found;
 748
 749         ExtractDevice(path,path_absolute);
 750         if(path_absolute[0]=='\0')
 751         {
 752                 getcwd(path_absolute,SMB_MAXPATH);
 753                 ExtractDevice(path_absolute,path_absolute);
 754         }
 755
 756         smb_env* env;
 757         env=FindSMBEnv(path_absolute);
 758
 759         if (smb_absolute_path_no_device(path, path_absolute,env->pos) == NULL)
 760         {
 761                 r->_errno = EINVAL;
 762                 return -1;
 763         }
 764
 765         memset(&dentry, 0, sizeof(SMBDIRENTRY));
 766
 767         _SMB_lock();
 768         found = SMB_PathInfo(path_absolute, &dentry, env->smbconn);
 769         _SMB_unlock();
 770
 771         if (found != SMB_SUCCESS)
 772         {
 773                 r->_errno = ENOENT;
 774                 return -1;
 775         }
 776
 777         if (!(dentry.attributes & SMB_SRCH_DIRECTORY))
 778         {
 779                 r->_errno = ENOTDIR;
 780                 return -1;
 781         }
 782
 783         strcpy(env->currentpath, path_absolute);
 784         if (env->currentpath[0] != 0)
 785         {
 786                 if (env->currentpath[strlen(env->currentpath) - 1] != '\\')
 787                         strcat(env->currentpath, "\\");
 788         }
 789
 790         return 0;
 791 }
 792
 793 static int __smb_dirreset(struct _reent *r, DIR_ITER *dirState)
 794 {
 795         char path_abs[SMB_MAXPATH];
 796         SMBDIRSTATESTRUCT* state = (SMBDIRSTATESTRUCT*) (dirState->dirStruct);
 797         SMBDIRENTRY dentry;
 798
 799         memset(&dentry, 0, sizeof(SMBDIRENTRY));
 800
 801         _SMB_lock();
 802         SMB_FindClose(SMBEnv[state->env].smbconn);
 803
 804         strcpy(path_abs,SMBEnv[state->env].currentpath);
 805         strcat(path_abs,"*");
 806         int found = SMB_FindFirst(path_abs, SMB_SRCH_DIRECTORY | SMB_SRCH_SYSTEM | SMB_SRCH_HIDDEN | SMB_SRCH_READONLY | SMB_SRCH_ARCHIVE, &dentry, SMBEnv[state->env].smbconn);
 807         _SMB_unlock();
 808
 809         if (found != SMB_SUCCESS)
 810         {
 811                 r->_errno = ENOENT;
 812                 return -1;
 813         }
 814
 815         if (!(dentry.attributes & SMB_SRCH_DIRECTORY))
 816         {
 817                 r->_errno = ENOTDIR;
 818                 return -1;
 819         }
 820
 821         state->smbdir.size = dentry.size;
 822         state->smbdir.ctime = dentry.ctime;
 823         state->smbdir.atime = dentry.atime;
 824         state->smbdir.mtime = dentry.mtime;
 825         state->smbdir.attributes = dentry.attributes;
 826         strcpy(state->smbdir.name, dentry.name);
 827
 828         SMBEnv[state->env].first_item_dir = true;
 829         return 0;
 830 }
 831
 832 static DIR_ITER* __smb_diropen(struct _reent *r, DIR_ITER *dirState, const char *path)
 833 {
 834         char path_absolute[SMB_MAXPATH];
 835         int found;
 836         SMBDIRSTATESTRUCT* state = (SMBDIRSTATESTRUCT*) (dirState->dirStruct);
 837         SMBDIRENTRY dentry;
 838
 839         ExtractDevice(path,path_absolute);
 840         if(path_absolute[0]=='\0')
 841         {
 842                 getcwd(path_absolute,SMB_MAXPATH);
 843                 ExtractDevice(path_absolute,path_absolute);
 844         }
 845
 846         smb_env* env;
 847         env=FindSMBEnv(path_absolute);
 848         if (smb_absolute_path_no_device(path, path_absolute, env->pos) == NULL)
 849         {
 850                 r->_errno = EINVAL;
 851                 return NULL;
 852         }
 853         if (path_absolute[strlen(path_absolute) - 1] != '\\')
 854                 strcat(path_absolute, "\\");
 855
 856         if(!strcmp(path_absolute,"\\"))
 857                 env->diropen_root=true;
 858         else
 859                 env->diropen_root=false;
 860
 861         strcat(path_absolute, "*");
 862
 863
 864         memset(&dentry, 0, sizeof(SMBDIRENTRY));
 865         _SMB_lock();
 866         found = SMB_FindFirst(path_absolute, SMB_SRCH_DIRECTORY | SMB_SRCH_SYSTEM | SMB_SRCH_HIDDEN | SMB_SRCH_READONLY | SMB_SRCH_ARCHIVE, &dentry, env->smbconn);
 867         _SMB_unlock();
 868
 869         if (found != SMB_SUCCESS)
 870         {
 871                 r->_errno = ENOENT;
 872                 return NULL;
 873         }
 874
 875         if (!(dentry.attributes & SMB_SRCH_DIRECTORY))
 876         {
 877                 r->_errno = ENOTDIR;
 878                 return NULL;
 879         }
 880
 881         state->env=env->pos;
 882         state->smbdir.size = dentry.size;
 883         state->smbdir.ctime = dentry.ctime;
 884         state->smbdir.atime = dentry.atime;
 885         state->smbdir.mtime = dentry.mtime;
 886         state->smbdir.attributes = dentry.attributes;
 887         strcpy(state->smbdir.name, dentry.name);
 888         env->first_item_dir = true;
 889         return dirState;
 890 }
 891
 892 static int dentry_to_stat(SMBDIRENTRY *dentry, struct stat *st)
 893 {
 894         if (!st)
 895                 return -1;
 896         if (!dentry)
 897                 return -1;
 898
 899         st->st_dev = 0;
 900         st->st_ino = 0;
 901
 902         st->st_mode = ((dentry->attributes & SMB_SRCH_DIRECTORY) ? S_IFDIR
 903                         : S_IFREG);
 904         st->st_nlink = 1;
 905         st->st_uid = 1; // Faked
 906         st->st_rdev = st->st_dev;
 907         st->st_gid = 2; // Faked
 908         st->st_size = dentry->size;
 909         st->st_atime = dentry->atime/10000000.0 - 11644473600LL;
 910         st->st_spare1 = 0;
 911         st->st_mtime = dentry->mtime/10000000.0 - 11644473600LL;
 912         st->st_spare2 = 0;
 913         st->st_ctime = dentry->ctime/10000000.0 - 11644473600LL;
 914         st->st_spare3 = 0;
 915         st->st_blksize = 1024;
 916         st->st_blocks = (st->st_size + st->st_blksize - 1) / st->st_blksize; // File size in blocks
 917         st->st_spare4[0] = 0;
 918         st->st_spare4[1] = 0;
 919
 920         return 0;
 921 }
 922
 923 static int __smb_dirnext(struct _reent *r, DIR_ITER *dirState, char *filename,
 924                 struct stat *filestat)
 925 {
 926         int ret;
 927         SMBDIRSTATESTRUCT* state = (SMBDIRSTATESTRUCT*) (dirState->dirStruct);
 928         SMBDIRENTRY dentry;
 929
 930         if (SMBEnv[state->env].currentpath[0] == '\0' || filestat == NULL)
 931         {
 932                 r->_errno = ENOENT;
 933                 return -1;
 934         }
 935
 936         memset(&dentry, 0, sizeof(SMBDIRENTRY));
 937         if (SMBEnv[state->env].first_item_dir)
 938         {
 939                 SMBEnv[state->env].first_item_dir = false;
 940                 dentry.size = 0;
 941                 dentry.attributes = SMB_SRCH_DIRECTORY;
 942                 strcpy(dentry.name, ".");
 943
 944                 state->smbdir.size = dentry.size;
 945                 state->smbdir.ctime = dentry.ctime;
 946                 state->smbdir.atime = dentry.atime;
 947                 state->smbdir.mtime = dentry.mtime;
 948                 state->smbdir.attributes = dentry.attributes;
 949                 strcpy(state->smbdir.name, dentry.name);
 950                 strcpy(filename, dentry.name);
 951                 dentry_to_stat(&dentry, filestat);
 952
 953                 return 0;
 954         }
 955
 956         _SMB_lock();
 957         ret = SMB_FindNext(&dentry, SMBEnv[state->env].smbconn);
 958         if(ret==SMB_SUCCESS && SMBEnv[state->env].diropen_root && !strcmp(dentry.name,".."))
 959                 ret = SMB_FindNext(&dentry, SMBEnv[state->env].smbconn);
 960         _SMB_unlock();
 961
 962         if (ret == SMB_SUCCESS)
 963         {
 964                 state->smbdir.size = dentry.size;
 965                 state->smbdir.ctime = dentry.ctime;
 966                 state->smbdir.atime = dentry.atime;
 967                 state->smbdir.mtime = dentry.mtime;
 968                 state->smbdir.attributes = dentry.attributes;
 969                 strcpy(state->smbdir.name, dentry.name);
 970         }
 971         else
 972         {
 973                 r->_errno = ENOENT;
 974                 return -1;
 975         }
 976
 977         strcpy(filename, dentry.name);
 978
 979         dentry_to_stat(&dentry, filestat);
 980
 981         return 0;
 982 }
 983
 984 static int __smb_dirclose(struct _reent *r, DIR_ITER *dirState)
 985 {
 986         SMBDIRSTATESTRUCT* state = (SMBDIRSTATESTRUCT*) (dirState->dirStruct);
 987
 988         _SMB_lock();
 989         SMB_FindClose(SMBEnv[state->env].smbconn);
 990         _SMB_unlock();
 991
 992         memset(state, 0, sizeof(SMBDIRSTATESTRUCT));
 993         return 0;
 994 }
 995
 996 static int __smb_stat(struct _reent *r, const char *path, struct stat *st)
 997 {
 998         char path_absolute[SMB_MAXPATH];
 999         SMBDIRENTRY dentry;
1000
1001         ExtractDevice(path,path_absolute);
1002         if(path_absolute[0]=='\0')
1003         {
1004                 getcwd(path_absolute,SMB_MAXPATH);
1005                 ExtractDevice(path_absolute,path_absolute);
1006         }
1007
1008         smb_env* env;
1009         env=FindSMBEnv(path_absolute);
1010
1011         if (smb_absolute_path_no_device(path, path_absolute, env->pos) == NULL)
1012         {
1013                 r->_errno = EINVAL;
1014                 return -1;
1015         }
1016         _SMB_lock();
1017         if (SMB_PathInfo(path_absolute, &dentry, env->smbconn) != SMB_SUCCESS)
1018         {
1019                 _SMB_unlock();
1020                 r->_errno = ENOENT;
1021                 return -1;
1022         }
1023         _SMB_unlock();
1024
1025         if (dentry.name[0] == '\0')
1026         {
1027                 r->_errno = ENOENT;
1028                 return -1;
1029         }
1030
1031         dentry_to_stat(&dentry, st);
1032
1033         return 0;
1034 }
1035
1036 static int __smb_fstat(struct _reent *r, int fd, struct stat *st)
1037 {
1038         SMBFILESTRUCT *filestate = (SMBFILESTRUCT *) fd;
1039
1040         if (!filestate)
1041         {
1042                 r->_errno = EBADF;
1043                 return -1;
1044         }
1045
1046         st->st_size = filestate->len;
1047
1048         return 0;
1049 }
1050
1051 void MountDevice(const char *name,SMBCONN smbconn, int env)
1052 {
1053         devoptab_t *dotab_smb;
1054
1055         dotab_smb=(devoptab_t*)malloc(sizeof(devoptab_t));
1056
1057         dotab_smb->name=strdup(name);
1058         dotab_smb->structSize=sizeof(SMBFILESTRUCT); // size of file structure
1059         dotab_smb->open_r=__smb_open; // device open
1060         dotab_smb->close_r=__smb_close; // device close
1061         dotab_smb->write_r=__smb_write; // device write
1062         dotab_smb->read_r=__smb_read; // device read
1063         dotab_smb->seek_r=__smb_seek; // device seek
1064         dotab_smb->fstat_r=__smb_fstat; // device fstat
1065         dotab_smb->stat_r=__smb_stat; // device stat
1066         dotab_smb->link_r=NULL; // device link
1067         dotab_smb->unlink_r=NULL; // device unlink
1068         dotab_smb->chdir_r=__smb_chdir; // device chdir
1069         dotab_smb->rename_r=NULL; // device rename
1070         dotab_smb->mkdir_r=NULL; // device mkdir
1071
1072         dotab_smb->dirStateSize=sizeof(SMBDIRSTATESTRUCT); // dirStateSize
1073         dotab_smb->diropen_r=__smb_diropen; // device diropen_r
1074         dotab_smb->dirreset_r=__smb_dirreset; // device dirreset_r
1075         dotab_smb->dirnext_r=__smb_dirnext; // device dirnext_r
1076         dotab_smb->dirclose_r=__smb_dirclose; // device dirclose_r
1077         dotab_smb->statvfs_r=NULL;                      // device statvfs_r
1078         dotab_smb->ftruncate_r=NULL;               // device ftruncate_r
1079         dotab_smb->fsync_r=NULL;           // device fsync_r
1080         dotab_smb->deviceData=NULL;             /* Device data */
1081
1082         AddDevice(dotab_smb);
1083
1084         SMBEnv[env].pos=env;
1085         SMBEnv[env].smbconn=smbconn;
1086         SMBEnv[env].name=strdup(name);
1087         SMBEnv[env].SMBCONNECTED=true;
1088         SMBEnv[env].first_item_dir=false;
1089         SMBEnv[env].diropen_root=false;
1090         SMBEnv[env].devoptab=dotab_smb;
1091
1092         SMBEnableReadAhead(SMBEnv[env].name,32);
1093 }
1094
1095 bool smbInitDevice(const char* name, const char *user, const char *password, const char *share, const char *ip)
1096 {
1097         char myIP[16];
1098         int i;
1099         if(FirstInit)
1100         {
1101                 for(i=0;i<MAX_SMB_MOUNTED;i++)
1102                 {
1103                         SMBEnv[i].SMBCONNECTED=false;
1104                         SMBEnv[i].currentpath[0]='\\';
1105                         SMBEnv[i].currentpath[1]='\0';
1106                         SMBEnv[i].first_item_dir=false;
1107                         SMBEnv[i].pos=i;
1108                         SMBEnv[i].SMBReadAheadCache=NULL;
1109                 }
1110                 FirstInit=false;
1111         }
1112
1113         for(i=0;i<MAX_SMB_MOUNTED && SMBEnv[i].SMBCONNECTED;i++);
1114         if(i==MAX_SMB_MOUNTED) return false; //all allowed samba connections reached
1115
1116         if (if_config(myIP, NULL, NULL, true) < 0)
1117                 return false;
1118         SMBCONN smbconn;
1119         if(_SMB_mutex==LWP_MUTEX_NULL)LWP_MutexInit(&_SMB_mutex, false);
1120
1121         //root connect
1122         _SMB_lock();
1123         if (SMB_Connect(&smbconn, user, password, share, ip) != SMB_SUCCESS)
1124         {
1125                 _SMB_unlock();
1126                 //LWP_MutexDestroy(_SMB_mutex);
1127                 return false;
1128         }
1129         _SMB_unlock();
1130
1131         MountDevice(name,smbconn,i);
1132
1133         if(end_cache_thread == true) // never close thread
1134         {
1135                 lwp_t client_thread;
1136                 main_thread = LWP_GetSelf();
1137                 end_cache_thread = false;
1138                 LWP_CreateThread(&client_thread, process_cache_thread, NULL, NULL, 0, 80);
1139         }
1140         return true;
1141 }
1142
1143 bool smbInit(const char *user, const char *password, const char *share, const char *ip)
1144 {
1145         return smbInitDevice("smb", user, password, share, ip);
1146 }
1147
1148 void smbClose(const char* name)
1149 {
1150         smb_env *env;
1151         env=FindSMBEnv(name);
1152         if(env==NULL) return;
1153
1154         if(env->SMBCONNECTED)
1155         {
1156                 _SMB_lock();
1157                 SMB_Close(env->smbconn);
1158                 _SMB_unlock();
1159         }
1160         env->SMBCONNECTED=false;
1161         RemoveDevice(env->name);
1162         //LWP_MutexDestroy(_SMB_mutex);
1163 }
1164
1165 bool CheckSMBConnection(const char* name)
1166 {
1167         char device[50];
1168         int i;
1169         bool ret;
1170         smb_env *env;
1171
1172         for(i=0;i<50 && name[i]!='\0' && name[i]!=':';i++) device[i]=name[i];
1173         device[i]='\0';
1174
1175         env=FindSMBEnv(device);
1176         if(env==NULL) return false;
1177         _SMB_lock();
1178         ret=(SMB_Reconnect(&env->smbconn,true)==SMB_SUCCESS);
1179         _SMB_unlock();
1180         return ret;
1181 }