static uint64_t cephwrap_disk_free(struct vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
uint64_t *bsize,
uint64_t *dfree,
uint64_t *dsize)
{
struct statvfs statvfs_buf;
int ret;
if (!(ret = ceph_statfs(handle->data, smb_fname->base_name,
&statvfs_buf))) {
/*
* Provide all the correct values.
*/
*bsize = statvfs_buf.f_bsize;
*dfree = statvfs_buf.f_bavail;
*dsize = statvfs_buf.f_blocks;
DBG_DEBUG("[CEPH] bsize: %llu, dfree: %llu, dsize: %llu\n",
llu(*bsize), llu(*dfree), llu(*dsize));
return *dfree;
} else {
DBG_DEBUG("[CEPH] ceph_statfs returned %d\n", ret);
WRAP_RETURN(ret);
}
}
int GWEN_PathManager_FindFile(const char *destLib,
const char *pathName,
const char *fileName,
GWEN_BUFFER *fbuf) {
GWEN_DB_NODE *dbT;
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (dbT) {
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (dbT) {
int i;
const char *s;
GWEN_DB_NODE *dbN;
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
/* check all paths */
dbN=GWEN_DB_FindFirstGroup(dbT, "pair");
while(dbN) {
for (i=0; ; i++) {
s=GWEN_DB_GetCharValue(dbN, "path", i, 0);
if (!s)
break;
else {
FILE *f;
GWEN_Buffer_AppendString(tbuf, s);
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(tbuf, fileName);
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying \"%s\"",
GWEN_Buffer_GetStart(tbuf));
f=fopen(GWEN_Buffer_GetStart(tbuf), "r");
if (f) {
fclose(f);
DBG_DEBUG(GWEN_LOGDOMAIN,
"File \"%s\" found in folder \"%s\"",
fileName,
s);
GWEN_Buffer_AppendBuffer(fbuf, tbuf);
GWEN_Buffer_free(tbuf);
return 0;
}
GWEN_Buffer_Reset(tbuf);
}
}
dbN=GWEN_DB_FindNextGroup(dbN, "pair");
}
GWEN_Buffer_free(tbuf);
}
}
DBG_INFO(GWEN_LOGDOMAIN, "File \"%s\" not found", fileName);
return GWEN_ERROR_NOT_FOUND;
}
static long cephwrap_telldir(struct vfs_handle_struct *handle, DIR *dirp)
{
long ret;
DBG_DEBUG("[CEPH] telldir(%p, %p)\n", handle, dirp);
ret = ceph_telldir(handle->data, (struct ceph_dir_result *) dirp);
DBG_DEBUG("[CEPH] telldir(...) = %ld\n", ret);
WRAP_RETURN(ret);
}
GWEN_XMLNODE *GWEN_XMLNode_Path_Surface(GWEN_XMLNODE_PATH *np) {
if (np->pos==0) {
DBG_DEBUG(GWEN_LOGDOMAIN, "Root reached");
return 0;
}
DBG_DEBUG(GWEN_LOGDOMAIN, "Surfaced to %d", np->pos-1);
return np->nodes[--np->pos];
}
static int cephwrap_closedir(struct vfs_handle_struct *handle, DIR *dirp)
{
int result;
DBG_DEBUG("[CEPH] closedir(%p, %p)\n", handle, dirp);
result = ceph_closedir(handle->data, (struct ceph_dir_result *) dirp);
DBG_DEBUG("[CEPH] closedir(...) = %d\n", result);
WRAP_RETURN(result);
}
static int cephwrap_rmdir(struct vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
int result;
DBG_DEBUG("[CEPH] rmdir(%p, %s)\n", handle, smb_fname->base_name);
result = ceph_rmdir(handle->data, smb_fname->base_name);
DBG_DEBUG("[CEPH] rmdir(...) = %d\n", result);
WRAP_RETURN(result);
}
static int cephwrap_close(struct vfs_handle_struct *handle, files_struct *fsp)
{
int result;
DBG_DEBUG("[CEPH] close(%p, %p)\n", handle, fsp);
result = ceph_close(handle->data, fsp->fh->fd);
DBG_DEBUG("[CEPH] close(...) = %d\n", result);
WRAP_RETURN(result);
}
static ssize_t cephwrap_pread(struct vfs_handle_struct *handle, files_struct *fsp, void *data,
size_t n, off_t offset)
{
ssize_t result;
DBG_DEBUG("[CEPH] pread(%p, %p, %p, %llu, %llu)\n", handle, fsp, data, llu(n), llu(offset));
result = ceph_read(handle->data, fsp->fh->fd, data, n, offset);
DBG_DEBUG("[CEPH] pread(...) = %llu\n", llu(result));
WRAP_RETURN(result);
}
int AHB_DTAUS__AddNum(GWEN_BUFFER *dst,
unsigned int size,
const char *s) {
unsigned int i, j;
assert(dst);
assert(s);
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding num : %s", s);
i=strlen(s);
if (i>size) {
/* Error out here because e.g. truncated BLZ will lead to failed jobs. */
DBG_ERROR(AQBANKING_LOGDOMAIN, "Number \"%s\" too long: Has length %d but must not be longer than %d characters",
s, i, size);
return -1;
}
j=size-i;
if (j) {
unsigned int k;
for (k=0; k<j; k++)
GWEN_Buffer_AppendByte(dst, '0');
}
GWEN_Buffer_AppendString(dst, s);
return 0;
}
int AHB_DTAUS__AddDtaWord(GWEN_BUFFER *dst,
unsigned int size,
const char *s) {
unsigned int i;
unsigned int ssize;
assert(dst);
assert(size);
assert(s);
DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding DTA word: %s", s);
ssize=strlen(s);
if (ssize>size) {
/* Error out here because e.g. truncated accountid will lead to failed jobs. */
DBG_ERROR(AQBANKING_LOGDOMAIN, "Word \"%s\" too long: Has length %d but must not be longer than %d characters",
s, ssize, size);
return -1;
}
for (i=0; i<size; i++) {
char c;
if (i>=ssize)
c=0;
else
c=s[i];
if (c)
GWEN_Buffer_AppendByte(dst, c);
else
GWEN_Buffer_AppendByte(dst, ' ');
} /* for */
return 0;
}
void GWEN_Date__sampleTmplChars(GWEN_UNUSED const GWEN_DATE *t, const char *tmpl,
GWEN_UNUSED GWEN_BUFFER *buf,
GWEN_DATE_TMPLCHAR_LIST *ll) {
const char *s;
s=tmpl;
while(*s) {
if (strchr("YMDWw", *s)) {
GWEN_DATE_TMPLCHAR *e;
e=GWEN_Date__findTmplChar(ll, *s);
if (!e) {
/* new entry, create it */
e=GWEN_DateTmplChar_new(*s);
GWEN_DateTmplChar_List_Add(e, ll);
}
assert(e);
e->count++;
}
else {
DBG_DEBUG(GWEN_LOGDOMAIN, "Unknown character in template (%02x)",
*s);
}
s++;
}
}
unsigned int Debug_CreateKeyFingerprint(CRYP_RSAKEY *key1) {
IPCMESSAGE *kmsg1;
int ks1;
ERRORCODE err;
const char *ptr1;
unsigned int fp;
kmsg1=IPCMessage_new();
IPCMessage_SetBuffer(kmsg1,0,4096);
err=Cryp_RsaKey_ToMessage(key1, kmsg1, 1);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
}
ks1=IPCMessage_GetMessageSize(kmsg1);
ptr1=IPCMessage_GetMessageBegin(kmsg1);
fp=0;
while(ks1) {
fp+=(unsigned char)(*ptr1);
ptr1++;
ks1--;
} /* while */
IPCMessage_free(kmsg1);
DBG_DEBUG("Fingerprint is: %08x\n",fp);
return fp;
}
int GWEN_Directory_FindFileInPaths(const GWEN_STRINGLIST *paths,
const char *filePath,
GWEN_BUFFER *fbuf) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(paths);
while(se) {
GWEN_BUFFER *tbuf;
FILE *f;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
GWEN_Buffer_AppendString(tbuf, GWEN_StringListEntry_Data(se));
GWEN_Buffer_AppendString(tbuf, DIRSEP);
GWEN_Buffer_AppendString(tbuf, filePath);
DBG_VERBOUS(GWEN_LOGDOMAIN, "Trying \"%s\"",
GWEN_Buffer_GetStart(tbuf));
f=fopen(GWEN_Buffer_GetStart(tbuf), "r");
if (f) {
fclose(f);
DBG_DEBUG(GWEN_LOGDOMAIN,
"File \"%s\" found in folder \"%s\"",
filePath,
GWEN_StringListEntry_Data(se));
GWEN_Buffer_AppendBuffer(fbuf, tbuf);
GWEN_Buffer_free(tbuf);
return 0;
}
GWEN_Buffer_free(tbuf);
se=GWEN_StringListEntry_Next(se);
}
DBG_INFO(GWEN_LOGDOMAIN, "File \"%s\" not found", filePath);
return GWEN_ERROR_NOT_FOUND;
}
/* called when a task goes down */
static void prefork_terminate(struct tevent_context *ev,
struct loadparm_context *lp_ctx,
const char *reason,
void *process_context)
{
DBG_DEBUG("called with reason[%s]\n", reason);
}
static int streams_xattr_fstat(vfs_handle_struct *handle, files_struct *fsp,
SMB_STRUCT_STAT *sbuf)
{
struct smb_filename *smb_fname_base = NULL;
int ret = -1;
struct stream_io *io = (struct stream_io *)
VFS_FETCH_FSP_EXTENSION(handle, fsp);
if (io == NULL || fsp->base_fsp == NULL) {
return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
}
DBG_DEBUG("streams_xattr_fstat called for %s\n", fsp_str_dbg(io->fsp));
if (!streams_xattr_recheck(io)) {
return -1;
}
/* Create an smb_filename with stream_name == NULL. */
smb_fname_base = synthetic_smb_fname(talloc_tos(),
io->base,
NULL,
NULL,
fsp->fsp_name->flags);
if (smb_fname_base == NULL) {
errno = ENOMEM;
return -1;
}
if (smb_fname_base->flags & SMB_FILENAME_POSIX_PATH) {
ret = SMB_VFS_LSTAT(handle->conn, smb_fname_base);
} else {
ret = SMB_VFS_STAT(handle->conn, smb_fname_base);
}
*sbuf = smb_fname_base->st;
if (ret == -1) {
TALLOC_FREE(smb_fname_base);
return -1;
}
sbuf->st_ex_size = get_xattr_size(handle->conn,
smb_fname_base, io->xattr_name);
if (sbuf->st_ex_size == -1) {
TALLOC_FREE(smb_fname_base);
SET_STAT_INVALID(*sbuf);
return -1;
}
DEBUG(10, ("sbuf->st_ex_size = %d\n", (int)sbuf->st_ex_size));
sbuf->st_ex_ino = stream_inode(sbuf, io->xattr_name);
sbuf->st_ex_mode &= ~S_IFMT;
sbuf->st_ex_mode &= ~S_IFDIR;
sbuf->st_ex_mode |= S_IFREG;
sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;
TALLOC_FREE(smb_fname_base);
return 0;
}
static int cephwrap_statvfs(struct vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
vfs_statvfs_struct *statbuf)
{
struct statvfs statvfs_buf;
int ret;
ret = ceph_statfs(handle->data, smb_fname->base_name, &statvfs_buf);
if (ret < 0) {
WRAP_RETURN(ret);
} else {
statbuf->OptimalTransferSize = statvfs_buf.f_frsize;
statbuf->BlockSize = statvfs_buf.f_bsize;
statbuf->TotalBlocks = statvfs_buf.f_blocks;
statbuf->BlocksAvail = statvfs_buf.f_bfree;
statbuf->UserBlocksAvail = statvfs_buf.f_bavail;
statbuf->TotalFileNodes = statvfs_buf.f_files;
statbuf->FreeFileNodes = statvfs_buf.f_ffree;
statbuf->FsIdentifier = statvfs_buf.f_fsid;
DBG_DEBUG("[CEPH] f_bsize: %ld, f_blocks: %ld, f_bfree: %ld, f_bavail: %ld\n",
(long int)statvfs_buf.f_bsize, (long int)statvfs_buf.f_blocks,
(long int)statvfs_buf.f_bfree, (long int)statvfs_buf.f_bavail);
}
return ret;
}
static struct dirent *cephwrap_readdir(struct vfs_handle_struct *handle,
DIR *dirp,
SMB_STRUCT_STAT *sbuf)
{
struct dirent *result;
DBG_DEBUG("[CEPH] readdir(%p, %p)\n", handle, dirp);
result = ceph_readdir(handle->data, (struct ceph_dir_result *) dirp);
DBG_DEBUG("[CEPH] readdir(...) = %p\n", result);
/* Default Posix readdir() does not give us stat info.
* Set to invalid to indicate we didn't return this info. */
if (sbuf)
SET_STAT_INVALID(*sbuf);
return result;
}
static void cephwrap_disconnect(struct vfs_handle_struct *handle)
{
int ret;
if (!cmount) {
DBG_ERR("[CEPH] Error, ceph not mounted\n");
return;
}
/* Should we unmount/shutdown? Only if the last disconnect? */
if (--cmount_cnt) {
DBG_DEBUG("[CEPH] Not shuting down CEPH because still more connections\n");
return;
}
ret = ceph_unmount(cmount);
if (ret < 0) {
DBG_ERR("[CEPH] failed to unmount: %s\n", strerror(-ret));
}
ret = ceph_release(cmount);
if (ret < 0) {
DBG_ERR("[CEPH] failed to release: %s\n", strerror(-ret));
}
cmount = NULL; /* Make it safe */
}
int GWEN_Process_Redirect(GWEN_PROCESS *pr)
{
assert(pr);
pr->filesStdin[0]=-1;
pr->filesStdout[0]=-1;
pr->filesStderr[0]=-1;
if (pr->pflags & GWEN_PROCESS_FLAGS_REDIR_STDIN) {
int filedes[2];
DBG_DEBUG(GWEN_LOGDOMAIN, "Redirecting stdin");
if (pipe(filedes)) {
DBG_ERROR(GWEN_LOGDOMAIN, "pipe(): %s", strerror(errno));
return -1;
}
pr->filesStdin[0]=filedes[1];
pr->filesStdin[1]=filedes[0];
}
if (pr->pflags & GWEN_PROCESS_FLAGS_REDIR_STDOUT) {
int filedes[2];
DBG_DEBUG(GWEN_LOGDOMAIN, "Redirecting stdout");
if (pipe(filedes)) {
DBG_ERROR(GWEN_LOGDOMAIN, "pipe(): %s", strerror(errno));
return -1;
}
pr->filesStdout[0]=filedes[0];
pr->filesStdout[1]=filedes[1];
}
if (pr->pflags & GWEN_PROCESS_FLAGS_REDIR_STDERR) {
int filedes[2];
DBG_DEBUG(GWEN_LOGDOMAIN, "Redirecting stderr");
if (pipe(filedes)) {
DBG_ERROR(GWEN_LOGDOMAIN, "pipe(): %s", strerror(errno));
return -1;
}
pr->filesStderr[0]=filedes[0];
pr->filesStderr[1]=filedes[1];
}
return 0;
}
static int cephwrap_open(struct vfs_handle_struct *handle,
struct smb_filename *smb_fname,
files_struct *fsp, int flags, mode_t mode)
{
int result = -ENOENT;
DBG_DEBUG("[CEPH] open(%p, %s, %p, %d, %d)\n", handle,
smb_fname_str_dbg(smb_fname), fsp, flags, mode);
if (smb_fname->stream_name) {
goto out;
}
result = ceph_open(handle->data, smb_fname->base_name, flags, mode);
out:
DBG_DEBUG("[CEPH] open(...) = %d\n", result);
WRAP_RETURN(result);
}
static DIR *cephwrap_fdopendir(struct vfs_handle_struct *handle,
struct files_struct *fsp,
const char *mask,
uint32_t attributes)
{
int ret = 0;
struct ceph_dir_result *result;
DBG_DEBUG("[CEPH] fdopendir(%p, %p)\n", handle, fsp);
ret = ceph_opendir(handle->data, fsp->fsp_name->base_name, &result);
if (ret < 0) {
result = NULL;
errno = -ret; /* We return result which is NULL in this case */
}
DBG_DEBUG("[CEPH] fdopendir(...) = %d\n", ret);
return (DIR *) result;
}
static DIR *cephwrap_opendir(struct vfs_handle_struct *handle,
const struct smb_filename *smb_fname,
const char *mask, uint32_t attr)
{
int ret = 0;
struct ceph_dir_result *result;
DBG_DEBUG("[CEPH] opendir(%p, %s)\n", handle, smb_fname->base_name);
/* Returns NULL if it does not exist or there are problems ? */
ret = ceph_opendir(handle->data, smb_fname->base_name, &result);
if (ret < 0) {
result = NULL;
errno = -ret; /* We return result which is NULL in this case */
}
DBG_DEBUG("[CEPH] opendir(...) = %d\n", ret);
return (DIR *) result;
}
int EBC_Provider_GenerateTimeStamp(GWEN_UNUSED AB_PROVIDER *pro,
AB_USER *u,
GWEN_BUFFER *buf) {
char timestamp[40];
time_t ti;
struct tm *t;
ti=time(0);
/*
if (EBC_User_GetFlags(u) & EBC_USER_FLAGS_TIMESTAMP_FIX1) {
*/
t=gmtime(&ti);
snprintf(timestamp, sizeof(timestamp)-1,
"%04d-%02d-%02dT%02d:%02d:%02d.000Z",
t->tm_year+1900,
t->tm_mon+1,
t->tm_mday,
t->tm_hour,
t->tm_min,
t->tm_sec);
timestamp[sizeof(timestamp)-1]=0;
DBG_DEBUG(AQEBICS_LOGDOMAIN,
"Generated timestamp [%s]",
timestamp);
GWEN_Buffer_AppendString(buf, timestamp);
/*
}
else {
int thzone;
t=localtime(&ti);
thzone=-timezone/60;
if (t->tm_isdst>0)
thzone+=60;
snprintf(timestamp, sizeof(timestamp)-1,
"%04d-%02d-%02dT%02d:%02d:%02d.000%+03d:%02d",
t->tm_year+1900,
t->tm_mon+1,
t->tm_mday,
t->tm_hour,
t->tm_min,
t->tm_sec,
(int)(thzone/60),
abs(thzone%60));
timestamp[sizeof(timestamp)-1]=0;
DBG_DEBUG(AQEBICS_LOGDOMAIN,
"Generated timestamp [%s] (tz=%d, daylight=%d)",
timestamp, (int)timezone, t->tm_isdst);
GWEN_Buffer_AppendString(buf, timestamp);
}
*/
return 0;
}
void GWEN_Process_SignalHandler(int s)
{
int status;
pid_t pid;
switch (s) {
case SIGCHLD:
/* try to get the status */
pid=waitpid(0, &status, WNOHANG);
if (pid==-1) {
DBG_DEBUG(GWEN_LOGDOMAIN, "waitdpid(%d): %s", 0, strerror(errno));
}
else if (pid==0) {
/* process still running ?! */
DBG_DEBUG(GWEN_LOGDOMAIN, "Got a SIGCHLD but no child terminated ??");
}
else {
GWEN_PROCESS *pr;
/* som process terminated */
pr=GWEN_Process_FindProcess(pid);
if (!pr) {
DBG_NOTICE(GWEN_LOGDOMAIN, "No infomation about process \"%d\" available", (int)pid);
}
else {
GWEN_Process_MakeState(pr, status);
/* remove from list. If this process data is not used by the
* aplication it will now be freed, otherwise only the usage
* counter is decremented */
GWEN_Process_free(pr);
}
}
break;
default:
DBG_ERROR(GWEN_LOGDOMAIN, "Got unhandled signal \"%d\"", s);
break;
} /* switch */
}
int GWEN_LibLoader_LoadLibrary(GWEN_LIBLOADER *h,
const char *name)
{
const char *errorstring;
assert(h);
DBG_DEBUG(GWEN_LOGDOMAIN, "Loading library \"%s\"", name);
h->handle=dlopen(name, RTLD_LAZY);
if (!h->handle) {
#ifdef ENABLE_NLS
const char *orig_locale = setlocale(LC_MESSAGES, NULL);
char *currentLocale = strdup(orig_locale ? orig_locale : "C");
setlocale(LC_MESSAGES, "C");
#endif
/* The string is checked against the known "C" locale strings
below. We *have* to switch to the C locale temporarily because
otherwise the string might be any translated value. */
errorstring = dlerror();
#ifdef ENABLE_NLS
setlocale(LC_MESSAGES, currentLocale);
free(currentLocale);
#endif
DBG_INFO(GWEN_LOGDOMAIN, "dlopen(%s): %s", name, errorstring);
if (strstr(errorstring, "No such file")) {
if (strstr(errorstring, name)) {
return GWEN_ERROR_NOT_FOUND;
}
}
else if (strstr(errorstring, "undefined symbol:")) {
DBG_INFO(GWEN_LOGDOMAIN,
"GWEN: Error loading library: %s",
errorstring);
if (strstr(errorstring, name))
return GWEN_ERROR_COULD_NOT_RESOLVE;
else
return GWEN_ERROR_COULD_NOT_LOAD;
}
DBG_INFO(GWEN_LOGDOMAIN,
"GWEN: Error loading library: %s",
errorstring);
return GWEN_ERROR_COULD_NOT_LOAD;
}
DBG_INFO(GWEN_LOGDOMAIN, "Loaded library \"%s\"", name);
return 0;
}
int GWEN_PathManager_GetMatchingFilesRecursively(const char *destLib,
const char *pathName,
const char *subFolderName,
GWEN_STRINGLIST *sl,
const char *mask) {
GWEN_DB_NODE *dbT;
assert(gwen__paths);
dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
destLib);
if (dbT) {
dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,
pathName);
if (dbT) {
int i;
const char *s;
GWEN_DB_NODE *dbN;
GWEN_BUFFER *tbuf;
tbuf=GWEN_Buffer_new(0, 256, 0, 1);
/* check all paths */
dbN=GWEN_DB_FindFirstGroup(dbT, "pair");
while(dbN) {
for (i=0; ; i++) {
s=GWEN_DB_GetCharValue(dbN, "path", i, 0);
if (!s)
break;
else {
GWEN_Buffer_AppendString(tbuf, s);
if (subFolderName && *subFolderName) {
GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);
GWEN_Buffer_AppendString(tbuf, subFolderName);
}
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying \"%s\"",
GWEN_Buffer_GetStart(tbuf));
GWEN_Directory_GetMatchingFilesRecursively(GWEN_Buffer_GetStart(tbuf), sl, mask);
GWEN_Buffer_Reset(tbuf);
}
}
dbN=GWEN_DB_FindNextGroup(dbN, "pair");
}
GWEN_Buffer_free(tbuf);
}
}
return 0;
}
const char *GWEN_XMLNode_GetLocalizedCharValue(const GWEN_XMLNODE *n,
const char *name,
const char *defValue) {
GWEN_XMLNODE *nn=0;
GWEN_STRINGLIST *langl;
langl=GWEN_I18N_GetCurrentLocaleList();
if (langl) {
GWEN_STRINGLISTENTRY *se;
se=GWEN_StringList_FirstEntry(langl);
while(se) {
const char *l;
l=GWEN_StringListEntry_Data(se);
DBG_DEBUG(GWEN_LOGDOMAIN, "Trying locale \"%s\"", l);
assert(l);
nn=GWEN_XMLNode_FindFirstTag(n, name, "lang", l);
while(nn) {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(nn);
if (dn) {
if (dn->data && *(dn->data))
return dn->data;
}
nn=GWEN_XMLNode_FindNextTag(nn, name, "lang", l);
} /* while nn */
se=GWEN_StringListEntry_Next(se);
} /* while */
} /* if language list available */
/* otherwise try without locale */
nn=GWEN_XMLNode_FindFirstTag(n, name, 0, 0);
while(nn) {
GWEN_XMLNODE *dn;
dn=GWEN_XMLNode_GetFirstData(nn);
if (dn) {
if (dn->data)
return dn->data;
}
nn=GWEN_XMLNode_FindNextTag(nn, name, 0, 0);
}
return defValue;
}
FXFont *FOX16_HtmlCtx::_getFoxFont(HTML_FONT *fnt) {
FXFont *xfnt;
if (GWEN_INHERIT_ISOFTYPE(HTML_FONT, FXFont, fnt)) {
xfnt=GWEN_INHERIT_GETDATA(HTML_FONT, FXFont, fnt);
return xfnt;
}
else {
FXuint size;
FXuint weight;
FXuint slant;
FXuint encoding;
FXString face;
uint32_t flags;
if (HtmlFont_GetFontName(fnt))
face=HtmlFont_GetFontName(fnt);
else
face=_font->getName();
size=HtmlFont_GetFontSize(fnt);
weight=FXFont::Normal;
slant=_font->getSlant();
encoding=_font->getEncoding();
flags=HtmlFont_GetFontFlags(fnt);
if (flags & HTML_FONT_FLAGS_STRONG)
weight=FXFont::Bold;
if (flags & HTML_FONT_FLAGS_ITALIC)
slant=FXFont::Italic;
DBG_DEBUG(GWEN_LOGDOMAIN,
"Creating font [%s], size=%d, weight=%d, slant=%d, encoding=%d",
face.text(), size, weight, slant, encoding);
xfnt=new FXFont(FXApp::instance(), face, size, weight, slant, encoding);
if (xfnt==NULL) {
DBG_ERROR(GWEN_LOGDOMAIN,
"Could not create font [%s], size=%d, weight=%d, slant=%d, encoding=%d",
face.text(), size, weight, slant, encoding);
return NULL;
}
xfnt->create();
GWEN_INHERIT_SETDATA(HTML_FONT, FXFont, fnt, xfnt,
FOX16_HtmlCtxLinker::freeFontData);
return xfnt;
}
}
int GWEN_XMLNode_Path_Dive(GWEN_XMLNODE_PATH *np,
GWEN_XMLNODE *n) {
unsigned int i;
if (np->pos>=GWEN_XML_MAX_DEPTH) {
DBG_ERROR(GWEN_LOGDOMAIN, "Path too deep");
return 1;
}
/* check for double entries */
for (i=0; i<np->pos; i++) {
assert(np->nodes[i]!=n);
}
np->nodes[np->pos++]=n;
DBG_DEBUG(GWEN_LOGDOMAIN, "Dived to %d", np->pos);
return 0;
}
int Debug_CompareKeys(CRYP_RSAKEY *key1, CRYP_RSAKEY *key2) {
IPCMESSAGE *kmsg1, *kmsg2;
int ks1, ks2;
ERRORCODE err;
kmsg1=IPCMessage_new();
IPCMessage_SetBuffer(kmsg1,0,4096);
kmsg2=IPCMessage_new();
IPCMessage_SetBuffer(kmsg2,0,4096);
err=Cryp_RsaKey_ToMessage(key1, kmsg1, 1);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
}
err=Cryp_RsaKey_ToMessage(key2, kmsg2, 1);
if (!Error_IsOk(err)) {
DBG_ERROR_ERR(err);
}
ks1=IPCMessage_GetMessageSize(kmsg1);
ks2=IPCMessage_GetMessageSize(kmsg2);
DBG_DEBUG("Sizes: Key1=%d, Key2=%d\n",ks1, ks2);
if (ks1==ks2) {
const char *ptr1, *ptr2;
ptr1=IPCMessage_GetMessageBegin(kmsg1);
ptr2=IPCMessage_GetMessageBegin(kmsg2);
while(ks1) {
if (*ptr1!=*ptr2) {
DBG_ERROR("Keys differ !\n");
break;
ptr1++;
ptr2++;
ks1--;
}
} /* while */
}
IPCMessage_free(kmsg1);
IPCMessage_free(kmsg2);
if (!ks1)
return 0;
else
return 1;
}
