void
test_modules
(
void
)
{
processLibProcEntry* entries = NULL;
RU32 entryIndex = 0;
rList mods = NULL;
rSequence mod = NULL;
RPWCHAR path = NULL;
entries = processLib_getProcessEntries( TRUE );
CU_ASSERT_PTR_NOT_EQUAL_FATAL( entries, NULL );
CU_ASSERT_NOT_EQUAL_FATAL( entries[ entryIndex ].pid, 0 );
mods = processLib_getProcessModules( entries[ entryIndex ].pid );
CU_ASSERT_PTR_NOT_EQUAL( mods, NULL );
CU_ASSERT_TRUE( rList_getSEQUENCE( mods, RP_TAGS_DLL, &mod ) );
CU_ASSERT_TRUE( rSequence_getSTRINGW( mod, RP_TAGS_FILE_PATH, &path ) );
CU_ASSERT_PTR_NOT_EQUAL( path, NULL );
CU_ASSERT_NOT_EQUAL( rpal_string_strlenw( path ), 0 );
rSequence_free( mods );
rpal_memory_free( entries );
}
void
test_processInfo
(
void
)
{
processLibProcEntry* entries = NULL;
RU32 entryIndex = 0;
rSequence proc = NULL;
RPWCHAR path = NULL;
entries = processLib_getProcessEntries( TRUE );
CU_ASSERT_PTR_NOT_EQUAL_FATAL( entries, NULL );
CU_ASSERT_NOT_EQUAL_FATAL( entries[ entryIndex ].pid, 0 );
proc = processLib_getProcessInfo( entries[ entryIndex ].pid );
CU_ASSERT_PTR_NOT_EQUAL( proc, NULL );
CU_ASSERT_TRUE( rSequence_getSTRINGW( proc, RP_TAGS_FILE_PATH, &path ) );
CU_ASSERT_PTR_NOT_EQUAL( path, NULL );
CU_ASSERT_NOT_EQUAL( rpal_string_strlenw( path ), 0 );
rSequence_free( proc );
rpal_memory_free( entries );
}
void
test_handles
(
void
)
{
rList handles = NULL;
rSequence handle = NULL;
RU32 nHandles = 0;
RU32 nNamedHandles = 0;
RPWCHAR handleName = NULL;
handles = processLib_getHandles( 0, FALSE, NULL );
CU_ASSERT_PTR_NOT_EQUAL_FATAL( handles, NULL );
while( rList_getSEQUENCE( handles, RP_TAGS_HANDLE_INFO, &handle ) )
{
nHandles++;
}
CU_ASSERT_TRUE( 100 < nHandles );
rList_free( handles );
handles = processLib_getHandles( 0, TRUE, NULL );
CU_ASSERT_PTR_NOT_EQUAL_FATAL( handles, NULL );
while( rList_getSEQUENCE( handles, RP_TAGS_HANDLE_INFO, &handle ) )
{
nNamedHandles++;
CU_ASSERT_TRUE( rSequence_getSTRINGW( handle, RP_TAGS_HANDLE_NAME, &handleName ) );
CU_ASSERT_TRUE( 0 != rpal_string_strlenw( handleName ) );
}
CU_ASSERT_TRUE( nNamedHandles < nHandles );
rList_free( handles );
}
void
test_procEntries
(
void
)
{
processLibProcEntry* entries = NULL;
RU32 entryIndex = 0;
RU32 nEntries = 0;
entries = processLib_getProcessEntries( TRUE );
CU_ASSERT_PTR_NOT_EQUAL_FATAL( entries, NULL );
while( 0 != entries[ entryIndex ].pid )
{
nEntries++;
entryIndex++;
}
CU_ASSERT_TRUE( 5 < nEntries );
rpal_memory_free( entries );
entries = processLib_getProcessEntries( FALSE );
CU_ASSERT_PTR_NOT_EQUAL_FATAL( entries, NULL );
while( 0 != entries[ entryIndex ].pid )
{
nEntries++;
entryIndex++;
}
CU_ASSERT_TRUE( 5 < nEntries );
rpal_memory_free( entries );
}
void
test_memmap
(
void
)
{
processLibProcEntry* entries = NULL;
RU32 entryIndex = 0;
rList regions = NULL;
rSequence region = NULL;
RU32 nRegions = 0;
RU8 type = 0;
RU8 protect = 0;
RU64 ptr = 0;
RU64 size = 0;
entries = processLib_getProcessEntries( TRUE );
CU_ASSERT_PTR_NOT_EQUAL_FATAL( entries, NULL );
CU_ASSERT_NOT_EQUAL_FATAL( entries[ entryIndex ].pid, 0 );
regions = processLib_getProcessMemoryMap( entries[ entryIndex ].pid );
CU_ASSERT_PTR_NOT_EQUAL( regions, NULL );
while( rList_getSEQUENCE( regions, RP_TAGS_MEMORY_REGION, ®ion ) )
{
CU_ASSERT_TRUE( rSequence_getRU8( region, RP_TAGS_MEMORY_TYPE, &type ) );
CU_ASSERT_TRUE( rSequence_getRU8( region, RP_TAGS_MEMORY_ACCESS, &protect ) );
CU_ASSERT_TRUE( rSequence_getPOINTER64( region, RP_TAGS_BASE_ADDRESS, &ptr ) );
CU_ASSERT_TRUE( rSequence_getRU64( region, RP_TAGS_MEMORY_SIZE, &size ) );
nRegions++;
}
CU_ASSERT_TRUE( 2 < nRegions );
rSequence_free( regions );
rpal_memory_free( entries );
}
void
test_servicesList
(
void
)
{
rList svcs = NULL;
rSequence svc = NULL;
RU32 type = PROCESSLIB_SVCS;
#if defined( RPAL_PLATFORM_WINDOWS ) || defined( RPAL_PLATFORM_LINUX )
RPWCHAR svcName = NULL;
#elif defined( RPAL_PLATFORM_MACOSX )
RPCHAR svcName = NULL;
#endif
svcs = processLib_getServicesList( type );
CU_ASSERT_PTR_NOT_EQUAL_FATAL( svcs, NULL );
CU_ASSERT_TRUE( rList_getSEQUENCE( svcs, RP_TAGS_SVC, &svc ) );
#if defined( RPAL_PLATFORM_WINDOWS ) || defined( RPAL_PLATFORM_LINUX )
CU_ASSERT_TRUE( rSequence_getSTRINGW( svc, RP_TAGS_SVC_NAME, &svcName ) );
CU_ASSERT_PTR_NOT_EQUAL( svcName, NULL );
CU_ASSERT_NOT_EQUAL( rpal_string_strlenw( svcName ), 0 );
#elif defined( RPAL_PLATFORM_MACOSX )
CU_ASSERT_TRUE( rSequence_getSTRINGA( svc, RP_TAGS_SVC_NAME, &svcName ) );
CU_ASSERT_PTR_NOT_EQUAL( svcName, NULL );
CU_ASSERT_NOT_EQUAL( rpal_string_strlen( svcName ), 0 );
#endif
rSequence_free( svcs );
}
/**
* Closes the socket on failure.
*
* @param[in] up7 The upstream LDM-7 to be initialized.
* @param[in] sock The socket for the upstream LDM-7.
* @param[in] termFd Termination file-descriptor.
* @retval 0 Success.
*/
static int
up7_init(
Up7* const up7,
const int sock)
{
/*
* 0 => use default read/write buffer sizes.
* `sock` will be closed by `svc_destroy()`.
*/
SVCXPRT* const xprt = svcfd_create(sock, 0, 0);
CU_ASSERT_PTR_NOT_EQUAL_FATAL(xprt, NULL);
/*
* Set the remote address of the RPC server-side transport because
* `svcfd_create()` doesn't.
*/
{
struct sockaddr_in addr;
socklen_t addrLen = sizeof(addr);
int status = getpeername(sock, &addr, &addrLen);
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_EQUAL_FATAL(addrLen, sizeof(addr));
CU_ASSERT_EQUAL_FATAL(addr.sin_family, AF_INET);
xprt->xp_raddr = addr;
xprt->xp_addrlen = addrLen;
}
// Last argument == 0 => don't register with portmapper
bool success = svc_register(xprt, LDMPROG, SEVEN, ldmprog_7, 0);
CU_ASSERT_TRUE_FATAL(success);
up7->xprt = xprt;
return 0;
}
static void do_misc_tests(const char *fname, size_t len)
{
struct stat stat_info;
void *address;
FILE *fp = NULL;
size_t items;
int rc;
int fd;
int new_fd;
int status;
rc = stat(fname, &stat_info);
CU_ASSERT_EQUAL_FATAL(rc, 0);
CU_ASSERT_NOT_EQUAL_FATAL(stat_info.st_size, 0);
fd = open(fname, O_RDWR);
printf("Opened %s, fd = %d\n", fname, fd);
CU_ASSERT_NOT_EQUAL(fd, -1);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
new_fd = dup(fd);
printf("Duped %d, new_fd = %d\n", fd, new_fd);
CU_ASSERT_NOT_EQUAL(new_fd, -1);
status = dfuse_get_bypass_status(new_fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
rc = close(new_fd);
printf("close returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
new_fd = dup2(fd, 80);
printf("dup2(%d, 80) returned %d\n", fd, new_fd);
CU_ASSERT_EQUAL(new_fd, 80);
status = dfuse_get_bypass_status(new_fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
rc = close(new_fd);
printf("close returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
new_fd = fcntl(fd, F_DUPFD, 80);
printf("fcntl(%d, F_DUPFD, 80) returned %d\n", fd, new_fd);
CU_ASSERT(new_fd >= 80);
status = dfuse_get_bypass_status(new_fd);
printf("status = %d\n", status);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
rc = close(new_fd);
printf("close returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
new_fd = fcntl(fd, F_DUPFD_CLOEXEC, 90);
printf("fcntl(%d, F_DUPFD, 90) returned %d\n", fd, new_fd);
CU_ASSERT(new_fd >= 90);
status = dfuse_get_bypass_status(new_fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
rc = close(new_fd);
printf("close returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
rc = fsync(fd);
printf("fsync returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
rc = fdatasync(fd);
printf("fdatasync returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
new_fd = dup(fd);
printf("Duped %d, new_fd = %d\n", fd, new_fd);
CU_ASSERT_NOT_EQUAL(new_fd, -1);
status = dfuse_get_bypass_status(new_fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
address = mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
printf("mmap returned %p\n", address);
if (address == MAP_FAILED && errno == ENODEV) {
printf("mmap not supported on file system\n");
goto skip_mmap;
}
CU_ASSERT_PTR_NOT_EQUAL_FATAL(address, MAP_FAILED);
memset(address, '@', BUF_SIZE);
rc = munmap(address, BUF_SIZE);
printf("munmap returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_DIS_MMAP);
/* dup'd descriptor should also change status */
status = dfuse_get_bypass_status(new_fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_DIS_MMAP);
skip_mmap:
rc = close(fd);
printf("close returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
rc = close(new_fd);
printf("close returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
fd = open(fname, O_RDWR);
printf("Opened %s, fd = %d\n", fname, fd);
CU_ASSERT_NOT_EQUAL(fd, -1);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
fp = fdopen(fd, "r");
printf("fdopen returned %p\n", fp);
CU_ASSERT_PTR_NOT_EQUAL(fp, NULL);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_DIS_STREAM);
if (fp != NULL) {
char buf[16];
items = fread(buf, 1, 8, fp);
printf("Read %zd items, expected 8\n", items);
CU_ASSERT_EQUAL(items, 8);
CU_ASSERT_STRING_EQUAL(buf, "@@@@@@@@");
}
if (fp != NULL) {
rc = fclose(fp);
printf("fclose returned %d\n", rc);
} else {
rc = close(new_fd);
printf("close returned %d\n", rc);
}
CU_ASSERT_EQUAL(rc, 0);
fd = open(fname, O_RDWR);
printf("Opened %s, fd = %d\n", fname, fd);
CU_ASSERT_NOT_EQUAL(fd, -1);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_BYPASS);
rc = fcntl(fd, F_SETFL, O_APPEND);
printf("fcntl F_SETFL returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
status = dfuse_get_bypass_status(fd);
CU_ASSERT_EQUAL(status, DFUSE_IO_DIS_FCNTL);
rc = fcntl(fd, F_GETFL);
printf("fcntl F_GETFL returned %d\n", rc);
CU_ASSERT(rc & O_APPEND);
rc = close(fd);
printf("close returned %d\n", rc);
CU_ASSERT_EQUAL(rc, 0);
status = dfuse_get_bypass_status(0);
CU_ASSERT_EQUAL(status, DFUSE_IO_EXTERNAL);
status = dfuse_get_bypass_status(1);
CU_ASSERT_EQUAL(status, DFUSE_IO_EXTERNAL);
status = dfuse_get_bypass_status(2);
CU_ASSERT_EQUAL(status, DFUSE_IO_EXTERNAL);
}
