Esempio n. 1
0
int main()
{
  ID p1("Chris Lacher", 100), p2;
  std::cout << " IDs after declaration:\n"; 
  std::cout << "  p1 = " << p1 << '\n';
  std::cout << "  p2 = " << p2 << '\n';

  p1.SetName("Copy Checker");
  p1.SetAge(10);
  p2.SetName("Assign Checker");
  p2.SetAge(20);
  std::cout << " IDs after Set:\n"; 
  std::cout << "  p1 = " << p1 << '\n';
  std::cout << "  p2 = " << p2 << '\n';

  ID p3 = CopyCheck(p1);
  std::cout << " IDs after p3 = CopyCheck(p1):\n"; 
  std::cout << "  p1 = " << p1 << '\n';
  std::cout << "  p3 = " << p3 << '\n';

  // AssignCheck(p2, p3);
  std::cout << " IDs after AssignCheck(p2,p3):\n"; 
  std::cout << "  p2 = " << p2 << '\n';
  std::cout << "  p3 = " << p3 << '\n';

  ID p4 ("Transitive Assignment Check", 50);
  p1 = p2 = p3 = p4;
  std::cout << " IDs after p1 = p2 = p3 = p4:\n"; 
  std::cout << "  p1 = " << p1 << '\n';
  std::cout << "  p2 = " << p2 << '\n';
  std::cout << "  p3 = " << p3 << '\n';
  std::cout << "  p4 = " << p4 << '\n';

  ID * idarray = new ID [arraySize];
  std::cout << " ID Array after declaration:\n";
  for (size_t i = 0; i < arraySize; ++i)
    {
      std::cout << "  id[" << std::setw(numDigits) << i << "] = " << idarray[i] << '\n';
    } 

  for (size_t i = 0; i < arraySize; ++i)
    {
      idarray[i].SetName("A. B. Student");
      idarray[i].SetAge(17 + i);
    } 
  std::cout << " ID Array after Set:\n";
  for (size_t i = 0; i < arraySize; ++i)
    {
      std::cout << "  id[" << std::setw(numDigits) << i << "] = " << idarray[i] << '\n';
    } 

  delete [] idarray;
  // */
}
Esempio n. 2
0
DWORD CopyThem(
    FILENAME    *fnDir,
    CHAR        *chDest,
    CHAR        *chSrc,
    DWORD       nThread,
    DWORD       mask,
    BOOL        f1stPass
) {
    CHAR        *pch;
    CHAR        *pchSpotDest;
    CHAR        *pchSpotSrc;
    CHAR        chTemp[MAX_PATH];
    CHAR        chTempName[20];
    BOOL        fCopyIt;
    FILENAME    *fnChild;
    BOOL        fCopy;
    BOOL        fCopied;
    BOOL        fRenamed;
    BOOL        fDeleted;
    BOOL        fAttrib;
    DWORD       dwCount;
    DWORD       dwAttribs;
    DWORD       dw;

    fnChild = fnDir->fnChild.mem_ptr;

    pchSpotDest = chDest + strlen(chDest);
    pchSpotSrc  = chSrc  + strlen(chSrc);

    dwCount = 0;

    while ( fnChild ) {

        fCopyIt = TRUE;

        if ( f1stPass ) {
            if ( (fnChild->dwStatus & STARTED) == STARTED ) {
                fCopyIt = FALSE;
            }
        } else {
            if ( (fnChild->dwStatus & COPIED) == COPIED ) {
                fCopyIt = FALSE;
            }
        }

        //
        // If the file doesn't exist on this thread's source location, then
        // don't try to copy it.
        //
        if ( (fnChild->dwStatus & mask) != mask ) {
            fCopyIt = FALSE;
        }

        if ( fCopyIt ) {
//            if ( f1stPass && (fnChild->dwStatus & STARTED) == STARTED ) {
//                fCopyIt = FALSE;
//            } else {
//                fnChild->dwStatus |= STARTED;
//            }
//            LeaveCriticalSection( &pcs );
        }

        if ( fCopyIt ) {
            pch = pchSpotDest;

            strcpy( pch, fnChild->cFileName );
            strcpy( pchSpotSrc, pchSpotDest );

            if ( (fnChild->dwStatus & DIRECTORY) == DIRECTORY ) {
                CreateDirectory( chDest, NULL );
                strcat( pchSpotDest, "\\" );
                strcat( pchSpotSrc, "\\" );
                dwCount += CopyThem( fnChild, chDest, chSrc, nThread, mask, f1stPass );
            } else {
                fnChild->dwStatus |= STARTED;

                strcpy( chTemp, chDest );
                *(chTemp+(pchSpotDest-chDest)) = '\0';

                sprintf( chTempName, "suck%02lX.tmp", mask );
                strcat( chTemp, chTempName );

                //
                // Check if we need to copy this file
                //
                fCopy = CopyCheck( chDest, fnChild );

                if ( fScriptMode ) {
                    dwCount++;
                    EnterCriticalSection( &pcs );
                    fnChild->dwStatus |= COPIED;
                    if ( fCopy ) {
                        if ( !fQuietMode ) {
                            printf("copy %s %s\n", chSrc, chDest );
                        }
                        dwTotalSizes[nThread-1] += fnChild->dwFileSizeLow;
                    } else {
                        if ( !fQuietMode ) {
                            printf("rem copy %s %s\n", chSrc, chDest );
                        }
                    }
                    LeaveCriticalSection( &pcs );
                } else {
                    dwCount++;

                    if ( fCopy ) {

                        dwAttribs = GetFileAttributes( chTemp );
                        if ( dwAttribs & FILE_ATTRIBUTE_READONLY && dwAttribs != 0xFFFFFFFF ) {
                                dwAttribs &= ~FILE_ATTRIBUTE_READONLY;
                                fAttrib = SetFileAttributes( chTemp, dwAttribs );
                        }
                        fCopied = CopyFile( chSrc, chTemp, FALSE );

                        if ( !fCopying ) {
                            EnterCriticalSection( &pcs );
                            if ( !fCopying ) {
                                fCopying = TRUE;
                                printf("Copying files...\n" );
                            }
                            LeaveCriticalSection( &pcs );
                        }

                        if ( !fCopied ) {
                            dw = GetLastError();
                            printf("%s => %s\t[COPY ERROR %08lX]\n", chSrc, chTemp, dw );

                            dwAttribs = GetFileAttributes( chTemp );
                            if ( dwAttribs & FILE_ATTRIBUTE_READONLY && dwAttribs != 0xFFFFFFFF ) {
                                dwAttribs &= ~FILE_ATTRIBUTE_READONLY;
                                fAttrib = SetFileAttributes( chTemp, dwAttribs );
                            }
                            DeleteFile( chTemp );

                            switch( dw ) {
                                case ERROR_BAD_NETPATH:
                                case ERROR_BAD_NET_NAME:
                                    if ( !fProblems[nThread-1] ) {
                                        printf("Error accesing %s, switching to silent attempts\n", chSrc );
                                        fProblems[nThread-1] = TRUE;
                                    }
                                    Sleep( 10000 );      // Wait for 10 seconds
                                    break;
                                default:
                                    break;
                            }

                        } else {

                            EnterCriticalSection( &pcs );

                            if ( (fnChild->dwStatus & COPIED) == COPIED ) {
                                //
                                // Copy was done by somebody else
                                //
                                dwAttribs = GetFileAttributes( chTemp );
                                if ( dwAttribs & FILE_ATTRIBUTE_READONLY && dwAttribs != 0xFFFFFFFF ) {
                                        dwAttribs &= ~FILE_ATTRIBUTE_READONLY;
                                        fAttrib = SetFileAttributes( chTemp, dwAttribs );
                                }
                                fDeleted = DeleteFile( chTemp );

                            } else {
                                //
                                // Copy was done by us, attempt rename
                                //
                                fAttrib = TRUE;
                                if ( fDestroy ) {
                                    dwAttribs = GetFileAttributes( chDest );
                                    if ( dwAttribs & FILE_ATTRIBUTE_READONLY && dwAttribs != 0xFFFFFFFF ) {
                                        dwAttribs &= ~FILE_ATTRIBUTE_READONLY;
                                        fAttrib = SetFileAttributes( chDest, dwAttribs );
                                    }
                                }
                                if ( !fAttrib ) {
                                    dw = GetLastError();
                                    printf("%s => %s\t[ATTRIBUTE CHANGE ERROR %08lX(%s)\n", chSrc, chDest, dw, chDest );
                                    dwAttribs = GetFileAttributes( chTemp );
                                    if ( dwAttribs & FILE_ATTRIBUTE_READONLY && dwAttribs != 0xFFFFFFFF ) {
                                        dwAttribs &= ~FILE_ATTRIBUTE_READONLY;
                                        fAttrib = SetFileAttributes( chTemp, dwAttribs );
                                    }
                                    fDeleted = DeleteFile( chTemp );
                                } else {
                                    fDeleted = DeleteFile( chDest );
                                    if ( !fDeleted ) {
                                        dw = GetLastError();
                                        fnChild->dwStatus |= COPIED;
                                    }

                                    if ( fDeleted || dw == ERROR_FILE_NOT_FOUND ) {

                                        fRenamed = MoveFile( chTemp, chDest );

                                        if ( fRenamed ) {
                                            fnChild->dwStatus |= COPIED;
                                            if ( !fQuietMode ) {
                                                printf("%s => %s\t[OK]\n", chSrc, chDest );
                                            }
                                            dwTotalSizes[nThread-1] += fnChild->dwFileSizeLow;
                                        } else {
                                            dw = GetLastError();
                                            printf("%s => %s\t[RENAME ERROR %08lX (%s)]\n", chSrc, chDest, dw, chTemp );
                                            dwAttribs = GetFileAttributes( chTemp );
                                            if ( dwAttribs & FILE_ATTRIBUTE_READONLY && dwAttribs != 0xFFFFFFFF ) {
                                                dwAttribs &= ~FILE_ATTRIBUTE_READONLY;
                                                fAttrib = SetFileAttributes( chTemp, dwAttribs );
                                            }
                                            fDeleted = DeleteFile( chTemp );
                                        }
                                    } else {
                                        dw = GetLastError();
                                        printf("%s => %s\t[DELETE ERROR %08lX (%s)]\n", chSrc, chDest, dw, chDest );
                                        dwAttribs = GetFileAttributes( chTemp );
                                        if ( dwAttribs & FILE_ATTRIBUTE_READONLY && dwAttribs != 0xFFFFFFFF ) {
                                                dwAttribs &= ~FILE_ATTRIBUTE_READONLY;
                                                fAttrib = SetFileAttributes( chTemp, dwAttribs );
                                        }
                                        fDeleted = DeleteFile( chTemp );
                                    }
                                }
                            }
                            LeaveCriticalSection( &pcs );
                        }
                    } else {
                        EnterCriticalSection( &pcs );
                        if ( !fCopying ) {
                            fCopying = TRUE;
                            printf("Copying files...\n" );
                        }
                        fnChild->dwStatus |= COPIED;
                        if ( !fQuietMode ) {
                            // printf("%s => %s\t[OK]\n", chSrc, chDest );
                        }
                        LeaveCriticalSection( &pcs );
                    }
                }
            }

            *pchSpotDest = '\0';
            *pchSpotSrc  = '\0';
        }

        fnChild = fnChild->fnSibling.mem_ptr;
    }
    return( dwCount );
}