int init_SDL(void)
{
joy[0]=0;
joy[1]=0;
joy[2]=0;
joy[3]=0;
if (SDL_Init(SDL_INIT_JOYSTICK) < 0) {
fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
return(0);
}
sdlscreen = SDL_SetVideoMode(0,0, 16, SDL_SWSURFACE);
//We handle up to four joysticks
if(SDL_NumJoysticks())
{
int i;
SDL_JoystickEventState(SDL_ENABLE);
for(i=0;i<SDL_NumJoysticks();i++) {
joy[i]=SDL_JoystickOpen(i);
//Check for valid joystick, some keyboards
//aren't SDL compatible
if(joy[i])
{
if (SDL_JoystickNumAxes(joy[i]) > 28)
{
SDL_JoystickClose(joy[i]);
joy[i]=0;
logoutput("Error detected invalid joystick/keyboard\n");
}
else
joyCount++;
}
}
if(joy[0])
logoutput("Found %d joysticks\n",joyCount);
}
else
joyCount=1;
//sq frig number of players for keyboard
//joyCount=2;
SDL_EventState(SDL_ACTIVEEVENT,SDL_IGNORE);
SDL_EventState(SDL_SYSWMEVENT,SDL_IGNORE);
SDL_EventState(SDL_VIDEORESIZE,SDL_IGNORE);
SDL_EventState(SDL_USEREVENT,SDL_IGNORE);
SDL_ShowCursor(SDL_DISABLE);
//Initialise dispmanx
bcm_host_init();
//Clean exits, hopefully!
atexit(exitfunc);
return(1);
}
struct client_struct *register_client(unsigned int fd, pid_t pid, uid_t uid, gid_t gid, unsigned char type, int mode)
{
struct client_struct *client=NULL;
logoutput("register_client: for pid %i", (int) pid);
lock_clientslist();
/* check existing clients */
client=clients_list;
while (client) {
if ( client->pid==pid ) break;
client=client->next;
}
unlock_clientslist();
if ( client ) {
logoutput("register_client: client for pid %i does already exist", (int) pid);
} else {
client=create_client(fd, pid, uid, gid, type);
/* insert at begin of list */
if ( client) {
lock_clientslist();
add_client_to_list(client);
unlock_clientslist();
client->owner_id=new_owner_id();
client->mode=mode;
}
}
unlock:
return client;
}
static void workspace_nfs_write(fuse_req_t req, const char *buff, size_t size, off_t offset, struct workspace_fh_struct *fh)
{
struct resource_struct *resource=fh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
struct nfsfh *nfsfh=(struct nfsfh *) fh->handle.data;
int result=0;
logoutput("workspace_nfs_write");
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_pwrite(nfs_ctx, nfsfh, offset, size, (void *) (intptr_t) buff);
pthread_mutex_unlock(&nfs_export->mutex);
if (result>=0) {
fuse_reply_write(req, result);
} else {
fuse_reply_err(req, abs(result));
}
}
static void workspace_nfs_open(fuse_req_t req, struct workspace_fh_struct *fh)
{
struct resource_struct *resource=fh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
char *path=fh->pathinfo.path + fh->relpath;
struct nfsfh *nfsfh=NULL;
int result=0;
if (strlen(path)==0) path=(char *) rootpath;
logoutput("workspace_nfs_open, path %s", path);
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_open(nfs_ctx, path, fh->flags, &nfsfh);
pthread_mutex_unlock(&nfs_export->mutex);
if (result==0) {
fh->handle.data=(void *) nfsfh;
fuse_reply_open(req, fh->fi);
} else {
fuse_reply_err(req, abs(result));
}
free_path_pathinfo(&fh->pathinfo);
}
static void workspace_nfs_release(fuse_req_t req, struct workspace_fh_struct *fh)
{
struct resource_struct *resource=fh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
struct nfsfh *nfsfh=(struct nfsfh *) fh->handle.data;
struct fuse_file_info *fi=fh->fi;
logoutput("workspace_nfs_release");
if (nfsfh) {
int result=0;
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_close(nfs_ctx, nfsfh);
pthread_mutex_unlock(&nfs_export->mutex);
}
free(fh);
fi->fh=0;
fuse_reply_err(req, 0);
}
static void workspace_nfs_fgetattr(fuse_req_t req, struct workspace_fh_struct *fh)
{
struct resource_struct *resource=fh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
struct nfsfh *nfsfh=(struct nfsfh *) fh->handle.data;
int result=0;
struct stat st;
logoutput("workspace_nfs_fgetattr");
memset(&st, 0, sizeof(struct stat));
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_fstat(nfs_ctx, nfsfh, &st);
pthread_mutex_unlock(&nfs_export->mutex);
if (result==0) {
fuse_reply_attr(req, &st, fs_options.attr_timeout);
} else {
fuse_reply_err(req, -result);
}
}
void increase_use_reader_manager()
{
int res;
pthread_mutex_lock(&references_mutex);
if (references==0) {
res=pthread_create(&reader_manager_pthreadid, NULL, &cdromreader_thread, NULL);
if ( res==-1 ) {
logoutput("Error creating thread for caching audio read results(error: %i).", errno);
} else {
references=1;
}
} else {
references++;
}
pthread_mutex_unlock(&references_mutex);
}
int send_message(int fd, struct notifyfs_message_body *message, void *data, int len)
{
struct msghdr msg;
struct iovec io_vector[2];
int nreturn=0;
msg.msg_controllen=0;
msg.msg_control=NULL;
msg.msg_name=NULL;
msg.msg_namelen=0;
io_vector[0].iov_base=(void *) message;
io_vector[0].iov_len=sizeof(struct notifyfs_message_body);
io_vector[1].iov_base=data;
io_vector[1].iov_len=len;
msg.msg_iov=io_vector;
msg.msg_iovlen=2;
/* the actual sending */
nreturn=sendmsg(fd, &msg, 0);
if ( nreturn==-1 ) nreturn=-errno;
logoutput("send_message: return %i", nreturn);
out:
return nreturn;
}
static int fscd_destroy(struct workspace_object_struct *object, unsigned char flags)
{
logoutput("fscd_destroy");
fscd_umount(object);
return 0;
}
static void workspace_nfs_opendir(fuse_req_t req, struct workspace_dh_struct *dh)
{
struct resource_struct *resource=dh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
char *path=dh->pathinfo.path + dh->relpath;
unsigned int error=0;
struct directory_struct *directory=dh->directory;
struct nfsdir *dir=NULL;
int result=0;
if (strlen(path)==0) path=(char *) rootpath;
logoutput("workspace_nfs_opendir: path %s", path);
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_opendir(nfs_ctx, path, &dir);
pthread_mutex_unlock(&nfs_export->mutex);
if (result==0) {
dh->handle.data = (void *) dir;
fuse_reply_open(req, dh->fi);
free_path_pathinfo(&dh->pathinfo);
return;
} else {
error=abs(result);
}
logoutput("workspace_opendir, error %i", error);
fuse_reply_err(req, error);
free_path_pathinfo(&dh->pathinfo);
}
QVariant FileListModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid()) {
logoutput("data: no valid index");
return QVariant();
}
if (role != Qt::DisplayRole) return QVariant();
if (index.row()>=totalCount) {
logoutput("data: index row %i bigger than total %i", index.row(), totalCount);
return QVariant();
}
if (index.row()>=0) {
struct notifyfs_entry_struct *entry=NULL;
entry=get_cached_entry(index.row());
if (entry) {
char *name=get_data(entry->name);
QString entryName = QString::fromAscii(name, strlen(name));
// logoutput("data: name %s, entryindex %i, row %i", name, entry->index, index.row());
return entryName;
} else {
logoutput("data: no entry found for row %i, internal id %i", index.row(), index.internalId());
}
}
return QVariant();
}
static int fscd_assign(struct resource_struct *resource)
{
int nreturn=0;
/* only when dealing with an audio cd apply these calls */
if (resource->group==RESOURCE_GROUP_CDROM && resource->type==CDROM_TYPE_FS) {
logoutput("fscd_assign: positive for resource");
nreturn=1;
} else {
logoutput("fscd_assign: not positive for resource");
}
return nreturn;
}
void remove_old_entries(struct workspace_object_struct *object, struct directory_struct *directory, struct timespec *synctime)
{
struct entry_struct *entry;
logoutput("remove_old_entries: synctime %li:%li", synctime->tv_sec, synctime->tv_nsec);
/* TODO: add locking */
entry=(struct entry_struct *) directory->first;
while (entry) {
if (entry->inode && entry->inode->mode==0) {
entry=entry->name_next;
continue;
}
if (entry->synctime.tv_sec<synctime->tv_sec ||
(entry->synctime.tv_sec==synctime->tv_sec && entry->synctime.tv_nsec<synctime->tv_nsec)) {
struct entry_struct *next=entry->name_next;
unsigned int error=0;
logoutput("remove_old_entries: remove %s synctime %li:%li", entry->name.name, entry->synctime.tv_sec, entry->synctime.tv_nsec);
remove_entry(entry, &error);
if (error==0) queue_remove(object, entry, &error);
entry=next;
} else {
entry=entry->name_next;
}
}
}
static void workspace_nfs_readlink(fuse_req_t req, struct entry_struct *entry, struct call_info_struct *call_info)
{
struct resource_struct *resource=call_info->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
char *path=call_info->pathinfo.path + call_info->relpath;
int result=0;
int len=512;
char buffer[len];
if (strlen(path)==0) path=(char *) rootpath;
logoutput("workspace_nfs_readlink, path %s", path);
/*
TODO: make this buffer variable, only how to correct that?
what error gives nfs_readlink back when buffer is too small?
*/
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_readlink(nfs_ctx, path, buffer, len);
pthread_mutex_unlock(&nfs_export->mutex);
if (result<0) {
logoutput("workspace_nfs_readlink, error reading readlink of %s, error %i:%s", path, abs(result), nfs_get_error(nfs_ctx));
fuse_reply_err(req, abs(result));
} else {
fuse_reply_readlink(req, buffer);
}
free_path_pathinfo(&call_info->pathinfo);
}
int wait_for_notifyfs_reply(uint64_t unique, unsigned char seconds)
{
struct notifyfs_reply_struct *notifyfs_reply=NULL;
struct timespec expire_time;
int res=0;
get_current_time(&expire_time);
expire_time.tv_sec+=seconds;
pthread_mutex_lock(&received_reply_queue.mutex);
while(1) {
notifyfs_reply=lookup_notifyfs_reply(unique, &received_reply_queue);
if ( ! notifyfs_reply) {
res=pthread_cond_timedwait(&received_reply_queue.cond, &received_reply_queue.mutex, &expire_time);
if (res==ETIMEDOUT) {
res=-ETIMEDOUT;
break;
}
} else {
break;
}
}
if (notifyfs_reply) {
get_notifyfs_reply_queue(notifyfs_reply, &received_reply_queue);
res=abs(notifyfs_reply->error);
logoutput("wait_for_notifyfs_reply: received a reply(unique: %li), send at %li.%li, received ar %li.%li",
(long int) unique, notifyfs_reply->send_time.tv_sec, notifyfs_reply->send_time.tv_nsec, notifyfs_reply->reply_time.tv_sec, notifyfs_reply->reply_time.tv_nsec);
free(notifyfs_reply);
}
pthread_mutex_unlock(&received_reply_queue.mutex);
return res;
}
void FileListModel::entryremoved(int row1, int row2)
{
struct notifyfs_entry_struct *parent=NULL;
parent=get_entry(parentEntry);
if (! parent) return;
logoutput("FileListModel::entryremoved");
beginRemoveRows(QModelIndex(), row1, row2);
totalCount -= (row2 - row1 + 1);
endRemoveRows();
}
static int handle_inotify_fd(int fd, void *data, uint32_t events)
{
char outputstring[256];
int lenread=0;
char buff[INOTIFY_BUFF_LEN];
lenread=read(fd, buff, INOTIFY_BUFF_LEN);
if ( lenread<0 ) {
logoutput("handle_inotify_fd: error (%i) reading inotify events (fd: %i)", errno, fd);
} else {
int i=0, res;
struct inotify_event *i_event=NULL;
while(i<lenread) {
i_event = (struct inotify_event *) &buff[i];
if ( (i_event->mask & IN_Q_OVERFLOW) || i_event->wd==-1 ) {
/* what to do here: read again?? go back ??*/
goto next;
}
if ( (i_event->mask & IN_ISDIR) && ((i_event->mask & IN_OPEN) || (i_event->mask & IN_CLOSE_NOWRITE))) {
/* explicit ignore the reading of directories */
goto next;
}
evaluate_fsevent_inotify(i_event);
next:
i += INOTIFY_EVENT_SIZE + i_event->len;
}
}
return 0;
}
void FileListModel::fetchMore(const QModelIndex & /* index */)
{
int count=totalCount;
logoutput("fetchMore");
if (count<cachetotalcount) {
int remainder = cachetotalcount - count;
int itemsToFetch = qMin(100, remainder);
beginInsertRows(QModelIndex(), count, count+itemsToFetch-1);
totalCount += itemsToFetch;
endInsertRows();
}
}
static void overlay_releasedir(fuse_req_t req, struct workspace_dh_struct *dh)
{
struct overlay_readdir_struct *overlay_readdir=(struct overlay_readdir_struct *)dh->handle.data;
struct directory_struct *directory=NULL;
struct timespec synctime;
unsigned int error=0;
unsigned int mode=0;
logoutput("RELEASEDIR");
directory=dh->directory;
if (overlay_readdir) {
mode=overlay_readdir->mode;
close_readdir(overlay_readdir);
if (overlay_readdir->fd>0) {
close(overlay_readdir->fd);
overlay_readdir->fd=0;
}
free(overlay_readdir);
overlay_readdir=NULL;
}
fuse_reply_err(req, 0);
if (directory) {
/* when synced with backend and there were entries at start test these are not synced */
if ((dh->mode & _WORKSPACE_READDIR_MODE_NONEMPTY) && (mode & (_FW_READDIR_MODE_SIMPLE | _FW_READDIR_MODE_FULL))) remove_old_entries(dh->object, directory, &dh->synctime);
memcpy(&directory->synctime, &dh->synctime, sizeof(struct timespec));
}
clean_pathcache();
}
static int getSMBremotehost(char *source, char *options, char *host, int len, unsigned char *islocal)
{
int res;
int len0=(INET_ADDRSTRLEN>INET6_ADDRSTRLEN) ? INET_ADDRSTRLEN : INET6_ADDRSTRLEN;
char address[len0];
logoutput("get_remotehost_cifs: get host for source %s and options %s", source, options);
/* get the address from the mount source */
res=get_value_mountoptions(options, "addr", address, len0);
if (res>0) {
char port[16];
memset(port, '\0', 16);
res=get_value_mountoptions(options, "port", port, 16);
if (res>0) {
/* if port explicit in mountoptions take that */
res=get_hostname(address, port, host, len, islocal);
} else {
/* no port found in mountoptions: first take the default 445, then 139 */
res=get_hostname(address, "445", host, len, islocal);
if (res==-ENOENT) {
res=get_hostname(address, "139", host, len, islocal);
}
}
}
return res;
}
static void workspace_nfs_fsync(fuse_req_t req, int datasync, struct workspace_fh_struct *fh)
{
struct resource_struct *resource=fh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
struct nfsfh *nfsfh=(struct nfsfh *) fh->handle.data;
int result=0;
logoutput("workspace_nfs_fsync");
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_close(nfs_ctx, nfsfh);
pthread_mutex_unlock(&nfs_export->mutex);
fuse_reply_err(req, abs(result));
}
static int fscd_getattr(struct workspace_object_struct *object, struct userpolicy_struct *userpolicy, struct inode_struct *inode, char *path, struct stat *st)
{
int nreturn=-ENOENT;
logoutput("fscd_gettatr");
if (inode) {
if ( strlen(path)==0 || strcmp(path, "/")==0 || strcmp(path, ".")==0 || strcmp(path, "/.")==0 ) {
copy_stat(st, &inode->st);
nreturn=0;
}
}
return nreturn;
}
static int fscd_init(struct workspace_object_struct *object)
{
int nreturn=0, res;
logoutput("fscd_init");
/* check the resource is a fs cdrom */
if (object->role) {
if (strcmp(object->role->name, "local.dev.cdrom.fs") != 0) {
/* not a fs cdrom */
goto out;
}
} else if ( object->resource ) {
if (object->resource->group != RESOURCE_GROUP_CDROM) {
goto out;
} else if (object->resource->type != CDROM_TYPE_FS) {
goto out;
}
} else {
goto out;
}
out:
return nreturn;
}
struct resource_struct *create_ftp_network_resource()
{
struct resource_struct *resource=NULL;
struct net_ftp_network_struct *ftpnetwork=NULL;
logoutput("create_ftp_network_resource");
resource=get_resource();
if (!resource) goto out;
ftpnetwork=malloc(sizeof(struct net_ftp_network_struct));
if ( ! ftpnetwork ) {
free(resource);
resource=NULL;
goto out;
}
resource->parent=NULL;
resource->group=RESOURCE_GROUP_FTP;
resource->type=FTP_TYPE_NETWORK;
resource->primary=1;
resource->data=(void *) ftpnetwork;
ftpnetwork->detect_time.tv_sec=0;
ftpnetwork->detect_time.tv_nsec=0;
ftpnetwork->refresh_time.tv_sec=0;
ftpnetwork->refresh_time.tv_nsec=0;
/* the other way around compared to resource read from cache */
add_resource_to_list(resource, &ftp_resource_list);
out:
return resource;
}
bool FileListModel::canFetchMore(const QModelIndex & /* index */) const
{
logoutput("canFetchMore");
/* check three parameters:
- getViewCount, is what notifyfs reports
- getcachedtotalcount, is what is in cache
- totalCount, is the number of rows in the view
*/
if (totalCount<cachetotalcount) {
// logoutput("canFetchMore: totalCount %i less then available %i", totalCount, getViewCount());
return true;
}
// logoutput("canFetchMore: totalCount %i versus available %i", totalCount, getViewCount());
return false;
}
static void workspace_nfs_read(fuse_req_t req, size_t size, off_t offset, struct workspace_fh_struct *fh)
{
struct resource_struct *resource=fh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
struct nfsfh *nfsfh=(struct nfsfh *) fh->handle.data;
int result=0;
char *buff;
buff=malloc(size);
if (! buff) {
fuse_reply_err(req, ENOMEM);
return;
}
logoutput("workspace_nfs_read");
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_pread(nfs_ctx, nfsfh, offset, size, buff);
pthread_mutex_unlock(&nfs_export->mutex);
if (result>=0) {
fuse_reply_buf(req, buff, result);
} else {
fuse_reply_err(req, abs(result));
}
}
static void workspace_nfs_releasedir(fuse_req_t req, struct workspace_dh_struct *dh)
{
struct resource_struct *resource=dh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
struct nfsdir *dir=(struct nfsdir *) dh->handle.data;
struct directory_struct *directory=NULL;
logoutput("workspace_nfs_releasedir");
directory=dh->directory;
if (dir) {
pthread_mutex_lock(&nfs_export->mutex);
nfs_closedir(nfs_ctx, dir);
pthread_mutex_unlock(&nfs_export->mutex);
}
fuse_reply_err(req, 0);
if (directory) {
/* when synced with backend and there were entries at start test these are not synced */
if (dh->mode & _WORKSPACE_READDIR_MODE_NONEMPTY) remove_old_entries(dh->object, directory, &dh->synctime);
memcpy(&directory->synctime, &dh->synctime, sizeof(struct timespec));
}
// clean_pathcache();
}
int start_cdrom_reader_thread(pthread_t *pthreadid, struct resource_struct *resource)
{
int nreturn=0;
//
// create a thread to read the cd
//
nreturn=pthread_create(pthreadid, NULL, cdromreader_thread, (void *) resource);
if ( nreturn==-1 ) {
// some error creating the thread
nreturn=-errno;
logoutput("Error creating a new thread (error: %i).", abs(nreturn));
}
return nreturn;
}
void RunTests()
{
std::string output;
#ifdef IOS
const std::string baseDirectory = g_Config.flash0Directory + "../";
#else
const std::string baseDirectory = g_Config.memStickDirectory;
#endif
CoreParameter coreParam;
coreParam.cpuCore = g_Config.bJit ? CPU_JIT : CPU_INTERPRETER;
coreParam.gpuCore = g_Config.bSoftwareRendering ? GPU_SOFTWARE : GPU_GLES;
coreParam.enableSound = g_Config.bEnableSound;
coreParam.graphicsContext = PSP_CoreParameter().graphicsContext;
coreParam.mountIso = "";
coreParam.mountRoot = baseDirectory + "pspautotests/";
coreParam.startPaused = false;
coreParam.printfEmuLog = false;
coreParam.headLess = true;
coreParam.renderWidth = 480;
coreParam.renderHeight = 272;
coreParam.pixelWidth = 480;
coreParam.pixelHeight = 272;
coreParam.collectEmuLog = &output;
coreParam.unthrottle = true;
coreParam.updateRecent = false;
// Never report from tests.
std::string savedReportHost = g_Config.sReportHost;
g_Config.sReportHost = "";
for (size_t i = 0; i < ARRAY_SIZE(testsToRun); i++) {
const char *testName = testsToRun[i];
coreParam.fileToStart = baseDirectory + "pspautotests/tests/" + testName + ".prx";
std::string expectedFile = baseDirectory + "pspautotests/tests/" + testName + ".expected";
ILOG("Preparing to execute %s", testName);
std::string error_string;
output = "";
if (!PSP_Init(coreParam, &error_string)) {
ELOG("Failed to init unittest %s : %s", testsToRun[i], error_string.c_str());
PSP_CoreParameter().pixelWidth = pixel_xres;
PSP_CoreParameter().pixelHeight = pixel_yres;
return;
}
// Run the emu until the test exits
while (true) {
int blockTicks = usToCycles(1000000 / 10);
while (coreState == CORE_RUNNING) {
PSP_RunLoopFor(blockTicks);
}
// Hopefully coreState is now CORE_NEXTFRAME
if (coreState == CORE_NEXTFRAME) {
// set back to running for the next frame
coreState = CORE_RUNNING;
} else if (coreState == CORE_POWERDOWN) {
ILOG("Finished running test %s", testName);
break;
}
}
std::ifstream expected(expectedFile.c_str(), std::ios_base::in);
if (!expected) {
ELOG("Error opening expectedFile %s", expectedFile.c_str());
break;
}
std::istringstream logoutput(output);
int line = 0;
while (true) {
++line;
std::string e, o;
std::getline(expected, e);
std::getline(logoutput, o);
// Remove stray returns
e = TrimNewlines(e);
o = TrimNewlines(o);
if (e != o) {
ELOG("DIFF on line %i!", line);
ELOG("O: %s", o.c_str());
ELOG("E: %s", e.c_str());
}
if (expected.eof()) {
break;
}
if (logoutput.eof()) {
break;
}
}
PSP_Shutdown();
}
glViewport(0,0,pixel_xres,pixel_yres);
PSP_CoreParameter().pixelWidth = pixel_xres;
PSP_CoreParameter().pixelHeight = pixel_yres;
PSP_CoreParameter().headLess = false;
g_Config.sReportHost = savedReportHost;
}
static void read_ftp_config()
{
FILE *fp;
pathstring configfile;
char line[256];
char *sep, *option, *value;
/* set defaults */
strncpy(ftp_options.networkname, "FTP", WORKSPACE_OBJECT_NAMELENMAX);
ftp_options.enable=1;
ftp_options.override_uid=1;
ftp_options.uid_policy=FTP_UIDPOLICY_PUBLIC;
/* timeout directories are not refreshed */
ftp_options.dir_timeout=300; /* 5 minutes */
/* timeout a readdir command will max wait before data is received from peer */
ftp_options.readdir_peer_timeout=10;
/* timeout a read command will max wait before data is received from peer */
ftp_options.read_peer_timeout=10;
/* timeout a read command will wait for another read command to finish */
ftp_options.read_finish_timeout=10;
ftp_options.global_ftpserver_file=NULL;
ftp_options.private_ftpserver_file=NULL;
/* where is the ftp config file ?? */
snprintf(configfile, PATH_MAX, "%s/ftp.settings", DEFAULT_CONFIG_PATH);
fp=fopen(configfile, "r");
if (! fp) return;
while( ! feof(fp)) {
if ( ! fgets(line, 256, fp)) continue;
sep=strchr(line, '\n');
if (sep) *sep='\0';
sep=strchr(line, '=');
if (!sep) continue;
*sep='\0';
option=line;
value=sep+1;
if (strcmp(option, "ftp.global.network.name")==0) {
/* global network name for FTP
note the is a global value, and does not offers differentiation per user (language, preferences) */
if (strlen(value)>0) {
logoutput("read_ftp_config: setting ftp network name %s", value);
strncpy(ftp_options.networkname, value, WORKSPACE_OBJECT_NAMELENMAX);
}
} else if (strcmp(option, "ftp.override_uid")==0) {
/* override the uid/gid with certain values (todo: which) */
ftp_options.override_uid=atoi(value);
} else if (strcmp(option, "ftp.uid_policy")==0) {
/* the uid used to override */
if (strcmp(value, "private")==0) {
/* the private user, ie the user who owns the workspace */
ftp_options.uid_policy=FTP_UIDPOLICY_PRIVATE;
} else if (strcmp(value, "public")==0) {
/* the public user*/
ftp_options.uid_policy=FTP_UIDPOLICY_PUBLIC;
} else if (strcmp(value, "root")==0) {
/* the root user*/
ftp_options.uid_policy=FTP_UIDPOLICY_ROOT;
}
} else if (strcmp(option, "ftp.dir_timeout")==0) {
/* override the uid/gid with certain values (todo: which) */
ftp_options.dir_timeout=atoi(value);
} else if (strcmp(option, "ftp.global.servers")==0) {
/* a file with ftp servers for everyone */
ftp_options.global_ftpserver_file=check_path(value);
if ( ftp_options.global_ftpserver_file ) {
logoutput("read_ftp_config: file with global servers %s found", ftp_options.global_ftpserver_file);
} else {
logoutput("read_ftp_config: file with global servers %s not found", value);
}
} else if (strcmp(option, "ftp.private.servers")==0) {
/* TODO: make this a template !! */
/* a file with ftp servers for everyone */
ftp_options.private_ftpserver_file=check_path(value);
if ( ftp_options.private_ftpserver_file ) {
logoutput("read_ftp_config: file with private servers %s found", ftp_options.private_ftpserver_file);
} else {
logoutput("read_ftp_config: file with private servers %s not found", value);
}
}
}
if (fp) fclose(fp);
}
