int main(int argc, char **argv)
{
PLOptStatus os;
PLOptState *opt = PL_CreateOptState(argc, argv, "dh");
PRFileDesc* fd;
PRErrorCode err;
/* parse command line options */
while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) {
if (PL_OPT_BAD == os) continue;
switch (opt->option) {
case 'd': /* debug mode */
debug_mode = PR_TRUE;
break;
case 'h':
default:
Help();
return 2;
}
}
PL_DestroyOptState(opt);
lm = PR_NewLogModule( "testcase" );
(void) PR_MkDir( DIRNAME, 0777);
fd = PR_Open( DIRNAME FILENAME, PR_CREATE_FILE|PR_RDWR, 0666);
if (fd == 0) {
PRErrorCode err = PR_GetError();
fprintf(stderr, "create file fails: %d: %s\n", err,
PR_ErrorToString(err, PR_LANGUAGE_I_DEFAULT));
failed_already = PR_TRUE;
goto Finished;
}
PR_Close(fd);
if (PR_RmDir( DIRNAME ) == PR_SUCCESS) {
fprintf(stderr, "remove directory succeeds\n");
failed_already = PR_TRUE;
goto Finished;
}
err = PR_GetError();
fprintf(stderr, "remove directory fails with: %d: %s\n", err,
PR_ErrorToString(err, PR_LANGUAGE_I_DEFAULT));
(void) PR_Delete( DIRNAME FILENAME);
(void) PR_RmDir( DIRNAME );
return 0;
Finished:
if ( debug_mode ) printf("%s\n", ( failed_already ) ? "FAILED" : "PASS" );
return( (failed_already)? 1 : 0 );
} /* --- end main() */
/*
* r m _ d a s h _ r
*
* Remove a file, or a directory recursively.
*
*/
int
rm_dash_r(char *path)
{
PRDir *dir;
PRDirEntry *entry;
PRFileInfo fileinfo;
char filename[FNSIZE];
if (PR_GetFileInfo(path, &fileinfo) != PR_SUCCESS) {
/*fprintf(stderr, "Error: Unable to access %s\n", filename);*/
return -1;
}
if (fileinfo.type == PR_FILE_DIRECTORY) {
dir = PR_OpenDir(path);
if (!dir) {
PR_fprintf(errorFD, "Error: Unable to open directory %s.\n", path);
errorCount++;
return -1;
}
/* Recursively delete all entries in the directory */
while ((entry = PR_ReadDir(dir, PR_SKIP_BOTH)) != NULL) {
sprintf(filename, "%s/%s", path, entry->name);
if (rm_dash_r(filename))
return -1;
}
if (PR_CloseDir(dir) != PR_SUCCESS) {
PR_fprintf(errorFD, "Error: Could not close %s.\n", path);
errorCount++;
return -1;
}
/* Delete the directory itself */
if (PR_RmDir(path) != PR_SUCCESS) {
PR_fprintf(errorFD, "Error: Unable to delete %s\n", path);
errorCount++;
return -1;
}
} else {
if (PR_Delete(path) != PR_SUCCESS) {
PR_fprintf(errorFD, "Error: Unable to delete %s\n", path);
errorCount++;
return -1;
}
}
return 0;
}
int
CallPR_RmDirUsingFileURL(char *dirURL)
{
int32 result=-1;
const char *path;
char *escapedPath = unescapeURL(dirURL);
path = convertFileURLToNSPRCopaceticPath(escapedPath);
if (path != NULL) {
result = PR_RmDir(path);
}
if (escapedPath != NULL) freeMem(escapedPath);
return result;
}
/*
* delete the given file/directory and its sub files/directories
*/
int
ldbm_delete_dirs(char *path)
{
PRDir *dirhandle = NULL;
PRDirEntry *direntry = NULL;
char fullpath[MAXPATHLEN];
int rval = 0;
PRFileInfo info;
dirhandle = PR_OpenDir(path);
if (! dirhandle)
{
PR_Delete(path);
return 0;
}
while (NULL != (direntry =
PR_ReadDir(dirhandle, PR_SKIP_DOT | PR_SKIP_DOT_DOT)))
{
if (! direntry->name)
break;
PR_snprintf(fullpath, MAXPATHLEN, "%s/%s", path, direntry->name);
rval = PR_GetFileInfo(fullpath, &info);
if (PR_SUCCESS == rval)
{
if (PR_FILE_DIRECTORY == info.type)
rval += ldbm_delete_dirs(fullpath);
}
if (PR_FILE_DIRECTORY != info.type)
PR_Delete(fullpath);
}
PR_CloseDir(dirhandle);
/* remove the directory itself too */
rval += PR_RmDir(path);
return rval;
}
void
CommandEventHandler::do_rmdr(std::string path, std::ostringstream &out)
{
std::string ret = isDir(path);
const char *p = path.c_str();
// if it's a file, nothing special to do
if (ret.compare("TRUE") != 0)
{
if (ret.compare("FALSE") == 0)
{
rm(path);
return;
}
// if this does not exist, return
out << ret;
return;
}
// recurse for dir contents
PRDir *dir = PR_OpenDir(p);
PRDirEntry *entry = PR_ReadDir(dir, PR_SKIP_BOTH);
while (entry)
{
do_rmdr(joinPaths(path, std::string(entry->name)), out);
entry = PR_ReadDir(dir, PR_SKIP_BOTH);
}
if (PR_CloseDir(dir) != PR_SUCCESS)
{
out << "error: could not close dir object" << ENDL;
// maybe return;
}
if (PR_RmDir(p) != PR_SUCCESS)
out << std::string("error: could not remove " + path) << ENDL;
}
/*
* Socket_Misc_Test - test miscellaneous functions
*
*/
static PRInt32
Socket_Misc_Test(void)
{
PRIntn i, rv = 0, bytes, count, len;
PRThread *t;
PRThreadScope scope;
PRSemaphore *server_sem;
Server_Param *sparamp;
Client_Param *cparamp;
PRMonitor *mon2;
PRInt32 datalen;
/*
* We deliberately pick a buffer size that is not a nice multiple
* of 1024.
*/
#define TRANSMITFILE_BUF_SIZE (4 * 1024 - 11)
typedef struct {
char data[TRANSMITFILE_BUF_SIZE];
} file_buf;
file_buf *buf = NULL;
/*
* create file(s) to be transmitted
*/
if ((PR_MkDir(TEST_DIR, 0777)) < 0) {
printf("prsocket_test failed to create dir %s\n",TEST_DIR);
failed_already=1;
return -1;
}
small_file_fd = PR_Open(SMALL_FILE_NAME, PR_RDWR | PR_CREATE_FILE,0777);
if (small_file_fd == NULL) {
fprintf(stderr,"prsocket_test failed to create/open file %s\n",
SMALL_FILE_NAME);
failed_already=1;
rv = -1;
goto done;
}
buf = PR_NEW(file_buf);
if (buf == NULL) {
fprintf(stderr,"prsocket_test failed to allocate buffer\n");
failed_already=1;
rv = -1;
goto done;
}
/*
* fill in random data
*/
for (i = 0; i < TRANSMITFILE_BUF_SIZE; i++) {
buf->data[i] = i;
}
count = 0;
do {
len = (SMALL_FILE_SIZE - count) > TRANSMITFILE_BUF_SIZE ?
TRANSMITFILE_BUF_SIZE : (SMALL_FILE_SIZE - count);
bytes = PR_Write(small_file_fd, buf->data, len);
if (bytes <= 0) {
fprintf(stderr,
"prsocket_test failed to write to file %s\n",
SMALL_FILE_NAME);
failed_already=1;
rv = -1;
goto done;
}
count += bytes;
} while (count < SMALL_FILE_SIZE);
#ifdef XP_UNIX
/*
* map the small file; used in checking for data corruption
*/
small_file_addr = mmap(0, SMALL_FILE_SIZE, PROT_READ,
MAP_PRIVATE, small_file_fd->secret->md.osfd, 0);
if (small_file_addr == (void *) -1) {
fprintf(stderr,"prsocket_test failed to mmap file %s\n",
SMALL_FILE_NAME);
failed_already=1;
rv = -1;
goto done;
}
#endif
/*
* header for small file
*/
small_file_header = PR_MALLOC(SMALL_FILE_HEADER_SIZE);
if (small_file_header == NULL) {
fprintf(stderr,"prsocket_test failed to malloc header file\n");
failed_already=1;
rv = -1;
goto done;
}
memset(small_file_header, (int) PR_IntervalNow(),
SMALL_FILE_HEADER_SIZE);
/*
* setup large file
*/
large_file_fd = PR_Open(LARGE_FILE_NAME, PR_RDWR | PR_CREATE_FILE,0777);
if (large_file_fd == NULL) {
fprintf(stderr,"prsocket_test failed to create/open file %s\n",
LARGE_FILE_NAME);
failed_already=1;
rv = -1;
goto done;
}
/*
* fill in random data
*/
for (i = 0; i < TRANSMITFILE_BUF_SIZE; i++) {
buf->data[i] = i;
}
count = 0;
do {
len = (LARGE_FILE_SIZE - count) > TRANSMITFILE_BUF_SIZE ?
TRANSMITFILE_BUF_SIZE : (LARGE_FILE_SIZE - count);
bytes = PR_Write(large_file_fd, buf->data, len);
if (bytes <= 0) {
fprintf(stderr,
"prsocket_test failed to write to file %s: (%ld, %ld)\n",
LARGE_FILE_NAME,
PR_GetError(), PR_GetOSError());
failed_already=1;
rv = -1;
goto done;
}
count += bytes;
} while (count < LARGE_FILE_SIZE);
#ifdef XP_UNIX
/*
* map the large file; used in checking for data corruption
*/
large_file_addr = mmap(0, LARGE_FILE_SIZE, PROT_READ,
MAP_PRIVATE, large_file_fd->secret->md.osfd, 0);
if (large_file_addr == (void *) -1) {
fprintf(stderr,"prsocket_test failed to mmap file %s\n",
LARGE_FILE_NAME);
failed_already=1;
rv = -1;
goto done;
}
#endif
datalen = tcp_mesg_size;
thread_count = 0;
/*
* start the server thread
*/
sparamp = PR_NEW(Server_Param);
if (sparamp == NULL) {
fprintf(stderr,"prsocket_test: PR_NEW failed\n");
failed_already=1;
rv = -1;
goto done;
}
server_sem = PR_NewSem(0);
if (server_sem == NULL) {
fprintf(stderr,"prsocket_test: PR_NewSem failed\n");
failed_already=1;
rv = -1;
goto done;
}
mon2 = PR_NewMonitor();
if (mon2 == NULL) {
fprintf(stderr,"prsocket_test: PR_NewMonitor failed\n");
failed_already=1;
rv = -1;
goto done;
}
PR_EnterMonitor(mon2);
sparamp->addr_sem = server_sem;
sparamp->exit_mon = mon2;
sparamp->exit_counter = &thread_count;
sparamp->datalen = datalen;
t = PR_CreateThread(PR_USER_THREAD,
TransmitFile_Server, (void *)sparamp,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_UNJOINABLE_THREAD,
0);
if (t == NULL) {
fprintf(stderr,"prsocket_test: PR_CreateThread failed\n");
failed_already=1;
rv = -1;
goto done;
}
DPRINTF(("Created TCP server = 0x%x\n", t));
thread_count++;
/*
* wait till the server address is setup
*/
PR_WaitSem(server_sem);
/*
* Now start a bunch of client threads
*/
cparamp = PR_NEW(Client_Param);
if (cparamp == NULL) {
fprintf(stderr,"prsocket_test: PR_NEW failed\n");
failed_already=1;
rv = -1;
goto done;
}
cparamp->server_addr = tcp_server_addr;
cparamp->server_addr.inet.ip = PR_htonl(INADDR_LOOPBACK);
cparamp->exit_mon = mon2;
cparamp->exit_counter = &thread_count;
cparamp->datalen = datalen;
for (i = 0; i < num_transmitfile_clients; i++) {
/*
* Every other thread is a LOCAL/GLOBAL thread
*/
if (i & 1)
scope = PR_GLOBAL_THREAD;
else
scope = PR_LOCAL_THREAD;
t = PR_CreateThread(PR_USER_THREAD,
TransmitFile_Client, (void *) cparamp,
PR_PRIORITY_NORMAL,
scope,
PR_UNJOINABLE_THREAD,
0);
if (t == NULL) {
fprintf(stderr,"prsocket_test: PR_CreateThread failed\n");
rv = -1;
failed_already=1;
goto done;
}
DPRINTF(("Created TransmitFile client = 0x%lx\n", t));
thread_count++;
}
/* Wait for server and client threads to exit */
while (thread_count) {
PR_Wait(mon2, PR_INTERVAL_NO_TIMEOUT);
DPRINTF(("Socket_Misc_Test - thread_count = %d\n", thread_count));
}
PR_ExitMonitor(mon2);
done:
if (buf) {
PR_DELETE(buf);
}
#ifdef XP_UNIX
munmap(small_file_addr, SMALL_FILE_SIZE);
munmap(large_file_addr, LARGE_FILE_SIZE);
#endif
PR_Close(small_file_fd);
PR_Close(large_file_fd);
if ((PR_Delete(SMALL_FILE_NAME)) == PR_FAILURE) {
fprintf(stderr,"prsocket_test: failed to unlink file %s\n",
SMALL_FILE_NAME);
failed_already=1;
}
if ((PR_Delete(LARGE_FILE_NAME)) == PR_FAILURE) {
fprintf(stderr,"prsocket_test: failed to unlink file %s\n",
LARGE_FILE_NAME);
failed_already=1;
}
if ((PR_RmDir(TEST_DIR)) == PR_FAILURE) {
fprintf(stderr,"prsocket_test failed to rmdir %s: (%ld, %ld)\n",
TEST_DIR, PR_GetError(), PR_GetOSError());
failed_already=1;
}
printf("%-29s%s","Socket_Misc_Test",":");
printf("%2d Server %2d Clients\n",1, num_transmitfile_clients);
printf("%30s Sizes of Transmitted Files - %4d KB, %2d MB \n",":",
SMALL_FILE_SIZE/1024, LARGE_FILE_SIZE/(1024 * 1024));
return rv;
}
