00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include "ObjectManager.h"
00028 #include "UserManager.h"
00029 #include "RioError.h"
00030 #include "CommonLibraries.h"
00031
00032 #include <stdio.h>
00033 #include <string.h>
00034 #include <errno.h>
00035 #include <sys/stat.h>
00036 #include <unistd.h>
00037
00038 const char* const LOGFILE = "RIOUserManager.log";
00039 const char* const PASSWDFILE = "RIOpasswd";
00040
00041
00042
00043 CUserManager::CUserManager()
00044 {
00045 m_Mutex = new CMutex;
00046 m_FileRoot = NULL;
00047 m_UserRoot = NULL;
00048 m_initialized = false;
00049
00050 }
00051
00052
00053 CUserManager::~CUserManager()
00054 {
00055
00056
00057 if( m_FileRoot != NULL )
00058 delete [] m_FileRoot;
00059 m_FileRoot = 0;
00060 if( m_UserRoot != NULL )
00061 delete [] m_UserRoot;
00062 m_UserRoot = 0;
00063 delete m_Mutex;
00064 if( m_log.is_open() )
00065 m_log.close();
00066 }
00067
00068
00069
00070
00071
00072
00073 int CUserManager::Initialize( UserManagerConfig *Config )
00074 {
00075
00076
00077 FILE *PassFile;
00078
00079 if( Config->GenerateLogs )
00080 {
00081
00082 char LogFileName[ MaxPathSize ];
00083
00084 strcpy( LogFileName, Config->LogsDirectory );
00085 strcat( LogFileName, LOGFILE );
00086 m_log.open( LogFileName );
00087 }
00088
00089
00090 if( m_initialized )
00091 {
00092 if( m_log.is_open() )
00093 m_log << "Initialize(): Tried to initialize component "
00094 << "already initialized" << endl;
00095
00096 return ERROR_USERMANAGER + ERROR_INITIALIZED;
00097 }
00098
00099
00100 if( !m_Mutex->IsOpen() )
00101 {
00102 if( m_log.is_open() )
00103 m_log << "Initialize(): Failed to create mutex" << endl;
00104
00105 return ERROR_USERMANAGER + ERROR_CREATE_MUTEX;
00106 }
00107
00108
00109
00110
00111 strcpy( m_PasswdFileName, Config->ConfigsDirectory );
00112 strcat( m_PasswdFileName, PASSWDFILE );
00113
00114
00115
00116 PassFile = fopen( m_PasswdFileName, "r+" );
00117 if( PassFile == NULL )
00118 {
00119 RioErr << "Initialize(): Failed to check password file" << endl;
00120 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00121 }
00122
00123
00124 fclose( PassFile );
00125
00126 m_FileRoot = new char[strlen( Config->FileRoot ) + 1];
00127 strcpy( m_FileRoot, Config->FileRoot );
00128
00129 m_UserRoot = new char[strlen( Config->UserRoot ) + 1];
00130 strcpy( m_UserRoot, Config->UserRoot );
00131
00132 m_initialized = true;
00133
00134 return S_OK;
00135 }
00136
00137
00138 int CUserManager::Logon( char* UserName, char* Password, RioUser **User )
00139 {
00140 char localUserName[ MaxPathSize ];
00141 char localPassword[ MaxPathSize ];
00142 int result;
00143 struct stat mystat;
00144 char name [2*MaxPathSize+1];
00145 int TotalFields;
00146
00147
00148 FILE *PassFile;
00149
00150
00151 *User = 0;
00152
00153 RioUser *newuser = new RioUser( this );
00154 if( newuser == 0 )
00155 {
00156 if( m_log.is_open() )
00157 m_log << " Error when allocating RioUser! " << UserName << endl;
00158
00159 return ERROR_USERMANAGER + ERROR_MEMORY;
00160 }
00161
00162 if( strlen( UserName ) == 0 )
00163 {
00164 if( m_log.is_open() )
00165 m_log << " Invalid User " << UserName << endl;
00166
00167 return ERROR_USERMANAGER + ERROR_INVALID_USER;
00168 }
00169
00170 if( strcmp( UserName, "guest" ) != 0 )
00171 {
00172
00173
00174 m_Mutex->Wait();
00175
00176
00177 PassFile = fopen( m_PasswdFileName, "r" );
00178 if( PassFile != NULL )
00179 {
00180 while( ( TotalFields = fscanf( PassFile, "%s %s",
00181 localUserName, localPassword ) )
00182 != EOF )
00183 {
00184 if( ( TotalFields == 2) &&
00185 ( strcmp( localUserName, UserName ) == 0 ) )
00186 break;
00187 else if( TotalFields == 1 )
00188 {
00189
00190
00191 if( m_log.is_open() )
00192 m_log << "User " << localUserName << " in file "
00193 << m_PasswdFileName << " ignored because "
00194 << "does not have a password!"<< endl;
00195
00196 }
00197 }
00198
00199
00200
00201
00202 if( errno != 0 )
00203 {
00204
00205
00206
00207 if( m_log.is_open() )
00208 m_log << "Error " << errno << " (" << strerror( errno )
00209 << ") when reading password file "
00210 << m_PasswdFileName << "!"<< endl;
00211 }
00212
00213
00214 fclose( PassFile );
00215
00216
00217 m_Mutex->Release();
00218
00219 if( strcmp( localUserName, UserName ) == 0 )
00220 {
00221 char *cryptPass;
00222 char salt[ 3 ];
00223
00224
00225 for( unsigned int i = 0; i < strlen( Password ); i++ )
00226 Password[ i ] = ( (Password[ i ] & 0x0F) << 4 ) |
00227 ( (Password[ i ] & 0xF0) >> 4 );
00228
00229 salt[ 0 ] = localPassword[ 0 ];
00230 salt[ 1 ] = localPassword[ 1 ];
00231 salt[ 2 ] = 0;
00232 cryptPass = crypt( Password, salt );
00233
00234 if( cryptPass == NULL )
00235 {
00236 if( m_log.is_open() )
00237 m_log << "Invalid User/Password [Failed to encrypt "
00238 << "user " << UserName << " password!]"
00239 << endl;
00240
00241 return ERROR_USERMANAGER + ERROR_MEMORY;
00242 }
00243
00244 if( strcmp( localPassword, cryptPass ) != 0 )
00245 {
00246 if( m_log.is_open() )
00247 m_log << "Invalid User/Password " << name << endl;
00248
00249 return ERROR_USERMANAGER + ERROR_INVALID_USER;
00250 }
00251 }
00252 else
00253 {
00254 if( m_log.is_open() )
00255 m_log << "Invalid User/Password " << name << endl;
00256
00257 return ERROR_USERMANAGER + ERROR_INVALID_USER;
00258 }
00259 }
00260 else
00261 {
00262
00263 m_Mutex->Release();
00264
00265 if( m_log.is_open() )
00266 m_log << "Invalid User/Password [Failed to open "
00267 << m_PasswdFileName << " file (errno=" << errno
00268 << ",strerr=" << strerror( errno ) << ")!]" << endl;
00269
00270 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00271 }
00272 }
00273
00274
00275 strcpy( name, m_FileRoot );
00276 strcat( name, "/" );
00277 strcat( name, UserName );
00278
00279 result = stat( name, &mystat );
00280
00281 if( ( result == 0 ) && ( !S_ISDIR( mystat.st_mode ) ) )
00282 {
00283 if( m_log.is_open() )
00284 m_log << "Invalid User/Password [" << name << " is not a directory!"
00285 << "]" << endl;
00286
00287 return ERROR_USERMANAGER + ERROR_INVALID_USER_DIRECTORY;
00288 }
00289 else if( result != 0 )
00290 {
00291 if( m_log.is_open() )
00292 m_log << "Invalid User/Password [stat for file " << name
00293 << " returned error " << errno << " (" << strerror( errno )
00294 << ")!]" << endl;
00295
00296 return ERROR_USERMANAGER + ERROR_INVALID_USER_DIRECTORY;
00297 }
00298
00299 newuser->user_home = new char[strlen( UserName ) + 1];
00300 if( newuser->user_home == 0 )
00301 {
00302 delete newuser;
00303 if( m_log.is_open() )
00304 m_log << " Error when allocating home user string path! "
00305 << UserName << endl;
00306
00307 return ERROR_USERMANAGER + ERROR_MEMORY;
00308 }
00309
00310 newuser->user = new char[strlen( UserName ) + 1];
00311 if( newuser->user == 0 )
00312 {
00313 delete[] newuser->user_home;
00314 delete newuser;
00315 if( m_log.is_open() )
00316 m_log << " Error when allocating user string! "
00317 << UserName << endl;
00318
00319 return ERROR_USERMANAGER + ERROR_MEMORY;
00320 }
00321
00322 strcpy( newuser->user_home, UserName );
00323 strcpy( newuser->user, UserName );
00324
00325 #ifdef RIO_DEBUG2
00326 if( m_log.is_open() )
00327 m_log << "User " << newuser->user_home << " log on." << endl;
00328 #endif
00329
00330
00331 *User = newuser;
00332
00333 return S_OK;
00334 }
00335
00336
00337 int CUserManager::CreateUser( char *UserName, char *Password )
00338 {
00339 char localUserName[ MaxPathSize ];
00340 char localPassword[ MaxPathSize ];
00341 int result;
00342 struct stat mystat;
00343 char name [2*MaxPathSize+1];
00344 int TotalFields;
00345
00346
00347 FILE *PassFile;
00348
00349 if( ( strlen( UserName ) == 0 ) || ( strcmp( UserName, "guest") == 0 ) )
00350 {
00351 if( m_log.is_open() )
00352 m_log << " Invalid User " << name << endl;
00353 return ERROR_USERMANAGER + ERROR_INVALID_USER;
00354 }
00355
00356 strcpy( name, m_FileRoot );
00357 strcat( name, "/" );
00358 strcat( name, UserName );
00359
00360
00361
00362 result = stat( name, &mystat );
00363
00364 if( ( result == 0 ) && ( !S_ISDIR( mystat.st_mode ) ) )
00365 {
00366
00367 if( m_log.is_open() )
00368 m_log << "Invalid User/Password [" << name << " is not a directory!"
00369 << "]" << endl;
00370
00371 return ERROR_USERMANAGER + ERROR_INVALID_USER_DIRECTORY;
00372 }
00373 else if( result < 0 )
00374 {
00375
00376 if( mkdir( name, 0700 ) != 0 )
00377 {
00378 if( m_log.is_open() )
00379 m_log << "Invalid User/Password [error " << errno << " ("
00380 << strerror( errno ) << ") when trying to create "
00381 << "directory "<< name << "!]" << endl;
00382
00383 return ERROR_USERMANAGER + ERROR_INVALID_USER_DIRECTORY;
00384
00385 }
00386 }
00387
00388
00389 m_Mutex->Wait();
00390
00391
00392 PassFile = fopen( m_PasswdFileName, "r+" );
00393 if( PassFile != NULL )
00394 {
00395 while( ( TotalFields = fscanf( PassFile, "%s %s",
00396 localUserName, localPassword ) )
00397 != EOF )
00398 {
00399 if( ( TotalFields == 2) &&
00400 ( strcmp( localUserName, UserName ) == 0 ) )
00401 {
00402
00403 fclose( PassFile );
00404
00405
00406
00407 m_Mutex->Release();
00408
00409 if( m_log.is_open() )
00410 m_log << "Invalid User/Password [User " << UserName
00411 << " already exists!]"<< endl;
00412
00413 return ERROR_USERMANAGER + ERROR_USER_EXISTS;
00414 }
00415 else if( TotalFields == 1 )
00416 {
00417
00418
00419 if( m_log.is_open() )
00420 m_log << "User " << localUserName << " in file "
00421 << m_PasswdFileName << " ignored because "
00422 << "does not have a password!"<< endl;
00423
00424 }
00425 }
00426
00427
00428
00429
00430 if( errno != 0 )
00431 {
00432
00433 fclose( PassFile );
00434
00435
00436
00437 m_Mutex->Release();
00438
00439
00440
00441
00442 if( m_log.is_open() )
00443 m_log << "Error " << errno << " (" << strerror( errno )
00444 << ") when reading password file "
00445 << m_PasswdFileName << "!"<< endl;
00446
00447 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00448 }
00449
00450
00451 if( fseek( PassFile, 0, SEEK_END ) < 0 )
00452 {
00453
00454 fclose( PassFile );
00455
00456
00457
00458 m_Mutex->Release();
00459
00460 if( m_log.is_open() )
00461 m_log << "Invalid User/Password [Failed to seek in "
00462 << m_PasswdFileName << " file (errno=" << errno
00463 << ",strerr=" << strerror( errno ) << ")!]"
00464 << endl;
00465
00466 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00467
00468 }
00469
00470
00471 char *cryptPass;
00472 char salt[ 3 ];
00473
00474
00475 for( unsigned int i = 0; i < strlen( Password ); i++ )
00476 Password[ i ] = ( ( Password[ i ] & 0x0F) << 4 ) |
00477 ( ( Password[ i ] & 0xF0) >> 4 );
00478
00479 salt[ 0 ] = localPassword[ 0 ];
00480 salt[ 1 ] = localPassword[ 1 ];
00481 salt[ 2 ] = 0;
00482 cryptPass = crypt( Password, salt );
00483
00484 if( cryptPass == NULL )
00485 {
00486
00487 fclose( PassFile );
00488
00489
00490
00491 m_Mutex->Release();
00492
00493 if( m_log.is_open() )
00494 m_log << "Invalid User/Password [Failed to encrypt "
00495 << "user " << UserName << " password!]" << endl;
00496
00497 return ERROR_USERMANAGER + ERROR_MEMORY;
00498 }
00499
00500
00501
00502
00503
00504
00505 if( fprintf( PassFile, "%s %s\n", UserName, cryptPass ) < 0 )
00506 {
00507
00508 fclose( PassFile );
00509
00510
00511
00512 m_Mutex->Release();
00513
00514 if( m_log.is_open() )
00515 m_log << "Invalid User/Password [Failed to save user/password "
00516 << "in " << m_PasswdFileName << " file (errno=" << errno
00517 << ",strerr=" << strerror( errno ) << ")!]" << endl;
00518
00519 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00520 }
00521
00522
00523 fclose( PassFile );
00524
00525
00526 m_Mutex->Release();
00527 }
00528 else
00529 {
00530
00531 m_Mutex->Release();
00532
00533 if( m_log.is_open() )
00534 m_log << "Invalid User/Password [Failed to open "
00535 << m_PasswdFileName << " file (errno=" << errno << ",strerr="
00536 << strerror( errno ) << ")!]" << endl;
00537
00538 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00539 }
00540
00541 return S_OK;
00542 }
00543
00544
00545 int CUserManager::RemoveUser( char *UserName )
00546 {
00547 char localUserName[ MaxPathSize ];
00548 char localPassword[ MaxPathSize ];
00549 int TotalFields;
00550
00551 char NewFileName[ MaxPathSize ];
00552
00553
00554 FILE *PassFile;
00555 FILE *NewPassFile;
00556
00557 if( ( strlen( UserName ) == 0 ) && ( strcmp( UserName, "guest" ) == 0 ) )
00558 {
00559 if( m_log.is_open() )
00560 m_log << " Invalid User " << UserName << endl;
00561
00562 return ERROR_USERMANAGER + ERROR_INVALID_USER;
00563 }
00564
00565
00566 strcpy( NewFileName, m_PasswdFileName );
00567 strcat( NewFileName, "." );
00568 strcat( NewFileName, "new" );
00569
00570
00571 m_Mutex->Wait();
00572
00573
00574 PassFile = fopen( m_PasswdFileName, "r" );
00575 if( PassFile != NULL )
00576 {
00577 while( ( TotalFields = fscanf( PassFile, "%s %s",
00578 localUserName, localPassword ) )
00579 != EOF )
00580 {
00581 if( ( TotalFields == 2) &&
00582 ( strcmp( localUserName, UserName ) == 0 ) )
00583 break;
00584 else if( TotalFields == 1 )
00585 {
00586
00587
00588 if( m_log.is_open() )
00589 m_log << "User " << localUserName << " in file "
00590 << m_PasswdFileName << " ignored because "
00591 << "does not have a password!"<< endl;
00592
00593 }
00594 }
00595
00596
00597
00598
00599 if( errno != 0 )
00600 {
00601
00602 fclose( PassFile );
00603
00604
00605
00606 m_Mutex->Release();
00607
00608
00609
00610
00611 if( m_log.is_open() )
00612 m_log << "Error " << errno << " (" << strerror( errno )
00613 << ") when reading password file "
00614 << m_PasswdFileName << "!"<< endl;
00615
00616 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00617 }
00618
00619
00620 if( strcmp( localUserName, UserName ) != 0 )
00621 {
00622
00623 fclose( PassFile );
00624
00625
00626
00627 m_Mutex->Release();
00628
00629 if( m_log.is_open() )
00630 m_log << " User " << UserName << "not found!" << endl;
00631
00632 return ERROR_USERMANAGER + ERROR_INVALID_USER;
00633 }
00634
00635
00636
00637 if( fseek( PassFile, 0, SEEK_SET ) < 0 )
00638 {
00639
00640 fclose( PassFile );
00641
00642
00643
00644 m_Mutex->Release();
00645
00646 if( m_log.is_open() )
00647 m_log << "Invalid User/Password [Failed to seek in "
00648 << m_PasswdFileName << " file (errno=" << errno
00649 << ",strerr=" << strerror( errno ) << ")!]"
00650 << endl;
00651
00652 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00653
00654 }
00655
00656
00657
00658 NewPassFile = fopen( NewFileName, "w+" );
00659 if( NewPassFile == NULL )
00660 {
00661
00662 fclose( PassFile );
00663
00664
00665 m_Mutex->Release();
00666
00667 if( m_log.is_open() )
00668 m_log << "Invalid User/Password [Failed to open "
00669 << m_PasswdFileName << " file (errno=" << errno
00670 << ",strerr=" << strerror( errno ) << ")!]" << endl;
00671
00672 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00673 }
00674
00675
00676
00677 while( ( TotalFields = fscanf( PassFile, "%s %s",
00678 localUserName, localPassword ) )
00679 != EOF )
00680 {
00681 if( ( TotalFields > 0 ) &&
00682 ( strcmp( localUserName, UserName ) != 0 ) )
00683 {
00684
00685
00686
00687
00688 if( TotalFields == 1 )
00689 strcmp( localPassword, "" );
00690
00691
00692
00693 if( fprintf( NewPassFile, "%s %s\n", localUserName,
00694 localPassword ) < 0 )
00695 {
00696
00697 fclose( NewPassFile );
00698
00699
00700 fclose( PassFile );
00701
00702
00703 m_Mutex->Release();
00704
00705 if( m_log.is_open() )
00706 m_log << "Invalid User/Password [Failed to save new "
00707 << "user " << UserName << "password in "
00708 << m_PasswdFileName << " file (errno=" << errno
00709 << ",strerr=" << strerror( errno ) << ")!]"
00710 << endl;
00711
00712 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00713 }
00714 }
00715 }
00716
00717
00718
00719
00720 if( errno != 0 )
00721 {
00722
00723 fclose( NewPassFile );
00724
00725
00726 fclose( PassFile );
00727
00728
00729 remove( NewFileName );
00730
00731
00732
00733 m_Mutex->Release();
00734
00735
00736
00737
00738 if( m_log.is_open() )
00739 m_log << "Error " << errno << " (" << strerror( errno )
00740 << ") when reading password file "
00741 << m_PasswdFileName << "!"<< endl;
00742
00743 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00744 }
00745
00746
00747 fclose( NewPassFile );
00748
00749
00750 fclose( PassFile );
00751
00752
00753 remove( m_PasswdFileName );
00754
00755
00756 rename( NewFileName, m_PasswdFileName );
00757
00758
00759 m_Mutex->Release();
00760 }
00761 else
00762 {
00763
00764 m_Mutex->Release();
00765
00766 if( m_log.is_open() )
00767 m_log << "Invalid User/Password [Failed to open "
00768 << m_PasswdFileName << " file (errno=" << errno
00769 << ",strerr=" << strerror( errno ) << ")!]" << endl;
00770
00771 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00772 }
00773
00774 return S_OK;
00775 }
00776
00777
00778 int CUserManager::ChangePassword( char *UserName, char *Password )
00779 {
00780 char localUserName[ MaxPathSize ];
00781 char localPassword[ MaxPathSize ];
00782 int TotalFields;
00783
00784
00785 FILE *PassFile;
00786
00787 if( ( strlen( UserName ) == 0 ) && ( strcmp( UserName, "guest" ) == 0 ) )
00788 {
00789 if( m_log.is_open() )
00790 m_log << " Invalid User " << UserName << endl;
00791
00792 return ERROR_USERMANAGER + ERROR_INVALID_USER;
00793 }
00794
00795
00796 m_Mutex->Wait();
00797
00798
00799 PassFile = fopen( m_PasswdFileName, "r+" );
00800 if( PassFile != NULL )
00801 {
00802 while( ( TotalFields = fscanf( PassFile, "%s %s",
00803 localUserName, localPassword ) )
00804 != EOF )
00805 {
00806 if( ( TotalFields == 2) &&
00807 ( strcmp( localUserName, UserName ) == 0 ) )
00808 break;
00809 else if( TotalFields == 1 )
00810 {
00811
00812
00813 if( m_log.is_open() )
00814 m_log << "User " << localUserName << " in file "
00815 << m_PasswdFileName << " ignored because "
00816 << "does not have a password!"<< endl;
00817
00818 }
00819 }
00820
00821
00822
00823
00824 if( errno != 0 )
00825 {
00826
00827 fclose( PassFile );
00828
00829
00830
00831 m_Mutex->Release();
00832
00833
00834
00835
00836 if( m_log.is_open() )
00837 m_log << "Error " << errno << " (" << strerror( errno )
00838 << ") when reading password file "
00839 << m_PasswdFileName << "!"<< endl;
00840
00841 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00842 }
00843
00844
00845 if( strcmp( localUserName, UserName ) != 0 )
00846 {
00847
00848 fclose( PassFile );
00849
00850
00851
00852 m_Mutex->Release();
00853
00854 if( m_log.is_open() )
00855 m_log << " User " << UserName << "not found!" << endl;
00856
00857 return ERROR_USERMANAGER + ERROR_INVALID_USER;
00858 }
00859
00860
00861
00862 if( fseek( PassFile,
00863 -( strlen( localUserName ) + strlen( localPassword ) + 1 ),
00864 SEEK_CUR ) < 0 )
00865 {
00866
00867 fclose( PassFile );
00868
00869
00870 m_Mutex->Release();
00871
00872 if( m_log.is_open() )
00873 m_log << "Invalid User/Password [Failed to seek in "
00874 << m_PasswdFileName << " file (errno=" << errno
00875 << ",strerr=" << strerror( errno ) << ")!]"
00876 << endl;
00877
00878 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00879
00880 }
00881
00882
00883 char *cryptPass;
00884 char salt[ 3 ];
00885
00886
00887 for( unsigned int i = 0; i < strlen( Password ); i++ )
00888 Password[ i ] = ( ( Password[ i ] & 0x0F ) << 4 ) |
00889 ( ( Password[ i ] & 0xF0 ) >> 4 );
00890
00891 salt[ 0 ] = localPassword[ 0 ];
00892 salt[ 1 ] = localPassword[ 1 ];
00893 salt[ 2 ] = 0;
00894 cryptPass = crypt( Password, salt );
00895
00896 if( cryptPass == NULL )
00897 {
00898
00899 fclose( PassFile );
00900
00901
00902
00903 m_Mutex->Release();
00904
00905 if( m_log.is_open() )
00906 m_log << "Invalid User/Password [Failed to encrypt "
00907 << "user " << UserName << " password!]" << endl;
00908
00909 return ERROR_USERMANAGER + ERROR_MEMORY;
00910 }
00911
00912
00913 if( fprintf( PassFile, "%s %s\n", UserName, cryptPass ) < 0 )
00914 {
00915
00916 fclose( PassFile );
00917
00918
00919 m_Mutex->Release();
00920
00921 if( m_log.is_open() )
00922 m_log << "Invalid User/Password [Failed to save new "
00923 << "user " << UserName << "password in "
00924 << m_PasswdFileName << " file (errno=" << errno
00925 << ",strerr=" << strerror( errno ) << ")!]"
00926 << endl;
00927
00928 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00929 }
00930
00931
00932 fclose( PassFile );
00933
00934
00935 m_Mutex->Release();
00936 }
00937 else
00938 {
00939
00940 m_Mutex->Release();
00941
00942 if( m_log.is_open() )
00943 m_log << "Invalid User/Password [Failed to open "
00944 << m_PasswdFileName << " file (errno=" << errno
00945 << ",strerr=" << strerror( errno ) << ")!]" << endl;
00946
00947 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
00948 }
00949
00950 return S_OK;
00951 }
00952
00953 int CUserManager::GetUserList( vector< string > &UserList )
00954 {
00955 char localUserName[ MaxPathSize ];
00956 char localPassword[ MaxPathSize ];
00957 int TotalFields;
00958
00959
00960
00961 FILE *PassFile;
00962
00963
00964 UserList.clear();
00965
00966 try
00967 {
00968 UserList.push_back( string( "guest" ) );
00969 }
00970 catch( bad_alloc &ba )
00971 {
00972 if( m_log.is_open() )
00973 m_log << "Error bac_alloc (" << ba.what()
00974 << ") when adding user guest to userlist!" << endl;
00975
00976
00977 UserList.clear();
00978
00979 return ERROR_USERMANAGER + ERROR_MEMORY;
00980
00981 }
00982
00983
00984 m_Mutex->Wait();
00985
00986
00987 PassFile = fopen( m_PasswdFileName, "r+" );
00988 if( PassFile != NULL )
00989 {
00990 while( ( TotalFields = fscanf( PassFile, "%s %s",
00991 localUserName, localPassword ) )
00992 != EOF )
00993 {
00994 if( TotalFields == 2)
00995 {
00996 try
00997 {
00998 UserList.push_back( string( localUserName ) );
00999 }
01000 catch( bad_alloc &ba )
01001 {
01002 if( m_log.is_open() )
01003 m_log << "Error bac_alloc (" << ba.what()
01004 << ") when adding a user " << localUserName
01005 << " to userlist!" << endl;
01006
01007
01008 fclose( PassFile );
01009
01010
01011
01012 m_Mutex->Release();
01013
01014
01015 UserList.clear();
01016
01017 return ERROR_USERMANAGER + ERROR_MEMORY;
01018
01019 }
01020 }
01021 else if( TotalFields == 1 )
01022 {
01023
01024
01025 if( m_log.is_open() )
01026 m_log << "User " << localUserName << " in file "
01027 << m_PasswdFileName << " ignored because "
01028 << "does not have a password!"<< endl;
01029
01030 }
01031 }
01032
01033
01034 fclose( PassFile );
01035
01036
01037
01038 m_Mutex->Release();
01039 }
01040 else
01041 {
01042
01043 m_Mutex->Release();
01044
01045 if( m_log.is_open() )
01046 m_log << "Invalid User/Password [Failed to open "
01047 << m_PasswdFileName << " file (errno=" << errno
01048 << ",strerr=" << strerror( errno ) << ")!]" << endl;
01049
01050
01051 UserList.clear();
01052
01053 return ERROR_USERMANAGER + ERROR_RIOPASSWORD_FILE;
01054 }
01055
01056 return S_OK;
01057 }
01058
01059 RioUser::RioUser()
01060 {
01061 u_mgr = NULL;
01062 user_home = NULL;
01063 user = NULL;
01064 }
01065
01066
01067 RioUser::RioUser( CUserManager *mgr )
01068 {
01069 u_mgr = mgr;
01070 user_home = NULL;
01071 user = NULL;
01072 }
01073
01074
01075 RioUser::~RioUser()
01076 {
01077 #ifdef RIO_DEBUG2
01078 if( u_mgr->m_log.is_open() )
01079 u_mgr->m_log << "User " << user_home << " log out.";
01080 #endif
01081
01082 if( user_home != 0 )
01083 {
01084 delete [] user_home;
01085 user_home = 0;
01086 }
01087
01088 if( user != 0 )
01089 {
01090 delete [] user;
01091 user = 0;
01092 }
01093 }
01094
01095
01096 int RioUser::GetUserHome(char **Path)
01097 {
01098 *Path = user_home;
01099 return S_OK;
01100 }
01101
01102
01103 int RioUser::GetUser(char **User)
01104 {
01105 *User = user;
01106 return S_OK;
01107 }
01108
01109
01110
01111 int RioUser::CheckAccess( const char *Path, const int action )
01112 {
01113 int status = ERROR_CONNECTIONMANAGER + ERROR_PERMISSION_DENIED;
01114
01115
01116 if( action == 1 )
01117 {
01118
01119
01120 if( strcmp( user, "root" ) == 0 )
01121 {
01122 #ifdef RIO_DEBUG2
01123 RioErr << "RioUser::CheckAccess o usuario " << user << " pode "
01124 << "sempre acessar para escrita qualquer caminho, incluindo "
01125 << Path << "!" << endl;
01126 #endif
01127
01128 status = S_OK;
01129 }
01130 else
01131 {
01132
01133
01134 char *FirstPathComponent;
01135
01136
01137 const char *StartFirstComponent, *EndFirstComponent;
01138
01139 unsigned int FirstPathComponentSize;
01140
01141
01142
01143 if( Path[ 0 ] == '/' )
01144 StartFirstComponent = &Path[ 1 ];
01145 else
01146 StartFirstComponent = Path;
01147
01148
01149 EndFirstComponent = strchr( StartFirstComponent, '/' );
01150 if( EndFirstComponent == NULL )
01151 EndFirstComponent = &Path[ strlen( Path ) ];
01152
01153
01154 FirstPathComponentSize = EndFirstComponent - StartFirstComponent;
01155
01156
01157
01158
01159
01160
01161 if( FirstPathComponentSize > 0 )
01162 {
01163 try
01164 {
01165 FirstPathComponent = new char[ FirstPathComponentSize + 1 ];
01166
01167
01168 strncpy( FirstPathComponent, StartFirstComponent,
01169 FirstPathComponentSize );
01170 FirstPathComponent[ FirstPathComponentSize ] = 0;
01171
01172 #ifdef RIO_DEBUG2
01173 RioErr << "RioUser::CheckAccess verificando se o usuario "
01174 << user << " pode acessar para escrita o caminho "
01175 << Path << ", sendo a primeira componente do "
01176 << "caminho igual a " << FirstPathComponent << " e "
01177 << "o caminho do diretorio do usuario sendo "
01178 << user_home << ": ";
01179 #endif
01180
01181
01182
01183 if( ( strcmp( FirstPathComponent, "var") == 0 ) ||
01184 ( strcmp( FirstPathComponent, user_home) == 0 ) )
01185 {
01186 #ifdef RIO_DEBUG2
01187 RioErr << "O usuario pode acessar o caminho!" << endl;
01188 #endif
01189
01190 status = S_OK;
01191 }
01192 #ifdef RIO_DEBUG2
01193 else
01194 RioErr << "O usuario nao pode acessar o caminho!"
01195 << endl;
01196 #endif
01197
01198
01199 delete[] FirstPathComponent;
01200 }
01201 catch( bad_alloc &ba )
01202 {
01203 if( u_mgr->m_log.is_open() )
01204 u_mgr->m_log << "[RioUser] Memory error when cheking"
01205 << " if user " << user << "can access "
01206 << "path " << Path << " (bad_alloc="
01207 << ba.what() << "). Returning permission "
01208 << "denied error!" << endl;
01209 }
01210 }
01211 }
01212 }
01213 else
01214 {
01215 #ifdef RIO_DEBUG2
01216 RioErr << "RioUser::CheckAccess o usuario " << user << " pode "
01217 << "sempre acessar para leitura qualquer caminho, incluindo "
01218 << Path << "!" << endl;
01219 #endif
01220
01221 status = S_OK;
01222 }
01223
01224 return status;
01225 }