int init_log(int debugger) {
int fd;
if (debugger > 0)
console_log = 1;
if (logrotate_timer == NULL) {
if ((logrotate_timer = new_Timer(SECS_IN_DAY, logrotate_timerfunc, TIMER_RESTART)) == NULL) {
log_err("init_log(): failed to allocate a new Timer");
return -1;
}
logrotate_reset_timer();
add_Timer(&timerq, logrotate_timer);
}
if (!console_log) {
if ((fd = open(PARAM_SYSLOG, O_WRONLY | O_CREAT | O_APPEND, (mode_t)0640)) == -1) {
log_err("failed to open logfile %s", PARAM_SYSLOG);
return -1;
}
#ifndef HAVE_DUP2
#error This platform has no dup2() function
#endif
close(fileno(stdout));
dup2(fd, fileno(stdout));
close(fd);
if ((fd = open(PARAM_AUTHLOG, O_WRONLY | O_CREAT | O_APPEND, (mode_t)0640)) == -1) {
log_err("failed to open logfile %s\n", PARAM_AUTHLOG);
return -1;
}
#ifndef HAVE_DUP2
#error This platform has no dup2() function
#endif
close(fileno(stderr));
dup2(fd, fileno(stderr));
close(fd);
}
if (!cstricmp(PARAM_LOGROTATE, "none")) { /* old; backwards compatibility */
Free(PARAM_LOGROTATE);
PARAM_LOGROTATE = cstrdup("never");
}
if (!cstricmp(PARAM_LOGROTATE, "never")
|| !cstricmp(PARAM_LOGROTATE, "daily")
|| !cstricmp(PARAM_LOGROTATE, "weekly")
|| !cstricmp(PARAM_LOGROTATE, "monthly")
|| !cstricmp(PARAM_LOGROTATE, "yearly"))
return 0;
log_warn("init_log(): unknown value '%s' for param logrotate; resetting to 'daily'");
Free(PARAM_LOGROTATE);
PARAM_LOGROTATE = cstrdup("daily");
return 0;
}
Room *load_Mail(char *username, int flags) {
Room *r;
char filename[MAX_PATHLEN], roomname[MAX_LINE];
if (username == NULL || !*username || !user_exists(username))
return NULL;
Enter(load_Mail);
bufprintf(filename, sizeof(filename), "%s/%c/%s/MailData", PARAM_USERDIR, *username, username);
path_strip(filename);
if ((r = load_RoomData(filename, MAIL_ROOM, flags)) == NULL) {
if ((r = new_Room()) == NULL) {
Return NULL;
}
r->generation = (unsigned long)rtc;
}
r->number = MAIL_ROOM;
possession(username, "Mail", roomname, MAX_LINE);
Free(r->name);
r->name = cstrdup(roomname);
if (in_StringList(r->invited, username) == NULL)
(void)prepend_StringList(&r->invited, new_StringList(username));
r->flags = ROOM_SUBJECTS | ROOM_NOZAP | ROOM_INVITE_ONLY;
bufprintf(filename, sizeof(filename), "%s/%c/%s/", PARAM_USERDIR, *username, username);
path_strip(filename);
room_readroomdir(r, filename, MAX_PATHLEN);
Return r;
}
bool select_card_by_name(const char *device_name)
{
int err;
bool opened;
char *msg;
close_hctl();
unplugged = FALSE;
opened = FALSE;
if (device_name) {
err = snd_mixer_attach(mixer, device_name);
if (err >= 0)
opened = TRUE;
else {
msg = casprintf(_("Cannot open mixer device '%s'."), device_name);
show_alsa_error(msg, err);
free(msg);
}
}
if (opened) {
mixer_device_name = cstrdup(device_name);
err = snd_mixer_load(mixer);
if (err < 0)
fatal_alsa_error(_("cannot load mixer controls"), err);
}
display_card_info();
set_view_mode(view_mode);
return opened;
}
Room *load_Home(char *username, int flags) {
Room *r;
char filename[MAX_PATHLEN], roomname[MAX_LINE];
if (username == NULL || !*username || !user_exists(username))
return NULL;
Enter(load_Home);
bufprintf(filename, sizeof(filename), "%s/%c/%s/HomeData", PARAM_USERDIR, *username, username);
path_strip(filename);
if ((r = load_RoomData(filename, 2, flags)) == NULL) {
if ((r = new_Room()) == NULL) {
Return NULL;
}
r->generation = (unsigned long)rtc;
}
r->number = HOME_ROOM;
possession(username, "Home", roomname, MAX_LINE);
Free(r->name);
r->name = cstrdup(roomname);
if (in_StringList(r->room_aides, username) == NULL)
(void)prepend_StringList(&r->room_aides, new_StringList(username));
if (in_StringList(r->invited, username) == NULL)
(void)prepend_StringList(&r->invited, new_StringList(username));
r->flags = ROOM_CHATROOM | ROOM_NOZAP | ROOM_INVITE_ONLY;
Return r;
}
static void logrotate_timerfunc(void *dummy) {
time_t t;
struct tm *tm;
dummy = NULL;
t = rtc;
tm = gmtime(&t);
if (!cstricmp(PARAM_LOGROTATE, "never")) {
logrotate_reset_timer(); /* keep timer running correctly anyway */
return;
}
if (!cstricmp(PARAM_LOGROTATE, "daily")
|| (!cstricmp(PARAM_LOGROTATE, "weekly") && tm->tm_wday == 1)
|| (!cstricmp(PARAM_LOGROTATE, "monthly") && tm->tm_mday == 1)
|| (!cstricmp(PARAM_LOGROTATE, "yearly") && tm->tm_yday == 1))
log_rotate(); /* will do an implicit logrotate_reset_timer() */
else {
log_err("unknown value '%s' for param logrotate, resetting to 'daily'", PARAM_LOGROTATE);
Free(PARAM_LOGROTATE);
PARAM_LOGROTATE = cstrdup("daily");
}
logrotate_reset_timer();
}
static void create_text_box(const char *const *lines, unsigned int count,
const char *title_, int attrs)
{
unsigned int i;
text_lines = ccalloc(count, sizeof *text_lines);
for (i = 0; i < count; ++i)
text_lines[i] = cstrdup(lines[i]);
text_lines_count = count;
max_line_width = get_max_mbs_width(lines, count);
title = cstrdup(title_);
widget_attrs = attrs;
current_top = 0;
current_left = 0;
create();
}
StringList *new_StringList(char *s) {
StringList *sl;
if (s == NULL || (sl = (StringList *)Malloc(sizeof(StringList), TYPE_STRINGLIST)) == NULL)
return NULL;
if ((sl->str = cstrdup(s)) == NULL) {
Free(sl);
return NULL;
}
return sl;
}
void RemoveThread::remove_file(char *path)
{
// Rename to temporary
uuid_t id;
uuid_generate(id);
char string[BCTEXTLEN];
strcpy(string, path);
uuid_unparse(id, string + strlen(string));
rename(path, string);
printf("RemoveThread:remove_file: renaming %s -> %s\n", path, string);
file_lock->lock("RemoveThread::remove_file");
files.append(cstrdup(string));
file_lock->unlock();
input_lock->unlock();
}
static char *dup_current_name(void)
{
int rows, cols, max, i;
char *s;
if (form_driver(form, REQ_VALIDATION) == E_OK) {
dynamic_field_info(fields[1], &rows, &cols, &max);
s = ccalloc(1, cols + 1);
memcpy(s, field_buffer(fields[1], 0), cols);
for (i = strlen(s) - 1; i >= 0 && s[i] == ' '; --i)
s[i] = '\0';
return s;
} else {
return cstrdup("");
}
}
void BatchRenderThread::calculate_dest_paths(ArrayList<char*> *paths,
Preferences *preferences)
{
for(int i = 0; i < jobs.total; i++)
{
BatchRenderJob *job = jobs.values[i];
if(job->enabled && *job->edl_path != '@')
{
PackageDispatcher *packages = new PackageDispatcher;
// Load EDL
TransportCommand *command = new TransportCommand;
FileXML *file = new FileXML;
file->read_from_file(job->edl_path);
// Use command to calculate range.
command->command = NORMAL_FWD;
command->get_edl()->load_xml(file,
LOAD_ALL);
command->change_type = CHANGE_ALL;
command->set_playback_range();
command->adjust_playback_range();
// Create test packages
packages->create_packages(mwindow,
command->get_edl(),
preferences,
job->strategy,
job->asset,
command->start_position,
command->end_position,
0);
// Append output paths allocated to total
for(int j = 0; j < packages->get_total_packages(); j++)
{
RenderPackage *package = packages->get_package(j);
paths->append(cstrdup(package->path));
}
// Delete package harness
delete packages;
delete command;
delete file;
}
}
}
/*
dl->name will be an allocated copy of dirname
dirname may be NULL, but then dl->name has to be set
dl->list will have the directory listing if successful
flags can be IGNORE_SYMLINKS|IGNORE_HIDDEN
*/
DirList *list_DirList(char *dirname, int flags) {
DirList *dl;
if (dirname == NULL || !*dirname)
return NULL;
if ((dl = new_DirList()) == NULL)
return NULL;
if ((dl->name = cstrdup(dirname)) == NULL) {
destroy_DirList(dl);
return NULL;
}
if ((dl->list = listdir(dl->name, flags)) == NULL) {
destroy_DirList(dl);
return NULL;
}
return dl;
}
/*
the symbol table is loaded from 'nm' output
All platforms have their own 'nm' output format, but luckily some
support POSIX format (although often poorly supported).
POSIX.2 format is <symbol> <type> <address> [<size>]
The symbol apperently may be empty on some systems
The address may be empty, when type is 'U'
The size is optional
*/
int load_SymbolTable(char *filename) {
AtomicFile *f;
char buf[MAX_LONGLINE], namebuf[MAX_LONGLINE], type;
unsigned long addr;
SymbolTable *st;
listdestroy_SymbolTable(symbol_table);
symbol_table = NULL;
if ((f = openfile(filename, "r")) == NULL)
return 1;
while(fgets(buf, MAX_LONGLINE, f->f) != NULL) {
cstrip_line(buf);
if (!*buf)
continue;
addr = 0UL;
type = '#';
cstrcpy(namebuf, "<unknown>", MAX_LONGLINE);
if (*buf == ' ')
sscanf(buf, " %c %lx", &type, &addr);
else
sscanf(buf, "%s %c %lx", namebuf, &type, &addr);
if ((st = new_SymbolTable()) == NULL) {
closefile(f);
listdestroy_SymbolTable(symbol_table);
symbol_table = NULL;
return -1;
}
st->name = cstrdup(namebuf);
st->type = type;
st->addr = addr;
symbol_table = add_SymbolTable(&symbol_table, st);
}
closefile(f);
symbol_table = rewind_SymbolTable(symbol_table);
return 0;
}
void create_mixer_object(struct snd_mixer_selem_regopt *selem_regopt)
{
int err;
err = snd_mixer_open(&mixer, 0);
if (err < 0)
fatal_alsa_error(_("cannot open mixer"), err);
mixer_device_name = cstrdup(selem_regopt->device);
err = snd_mixer_selem_register(mixer, selem_regopt, NULL);
if (err < 0)
fatal_alsa_error(_("cannot open mixer"), err);
snd_mixer_set_callback(mixer, mixer_callback);
err = snd_mixer_load(mixer);
if (err < 0)
fatal_alsa_error(_("cannot load mixer controls"), err);
err = snd_mixer_selem_id_malloc(¤t_selem_id);
if (err < 0)
fatal_error("out of memory");
}
int main(int argc, char ** argv)
{
FILE *f;
int rc;
cert_cxml_handler_t * h = cxml_st_handler_new(&Class, h_root);
h->vr_type = -1;
h->sa_type = -1;
argc = coptions(argc, argv, COPT_HELP_NOVALUES , options);
if(argc < 2){
if(argc<0 && (0-argc)<((sizeof(options)/sizeof(options[0]))-1)){
printf("Unknown option %s\n", argv[0-argc]);
}
const char * a = strrchr(argv[0], '/');
if (a == NULL) a = argv[0];
coptions_help(stdout, a, COPT_HELP_NOVALUES, options, "<profile> [signer]");
return -1;
}
if (_searchPath == NULL) _searchPath = _outPath;
if (_keyPath == NULL) _keyPath = _outPath;
_outFormat = copts_enum_value(options, 3, _o_formats);
if (_defaultTime == 0){
//set it to begining of this year
time_t t = time(NULL);
struct tm tm;
struct tm * ptm = gmtime(&t);
memcpy(&tm, ptm, sizeof(tm));
tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
tm.tm_mday = 1; tm.tm_mon = 0;
_defaultTime = mkitstime32(&tm);
}
if(argc > 2){
// set signer certificate file name
_signerName = argv[2];
}
f = fopen(argv[1], "rb");
if(f == NULL){
fprintf(stderr, "%s: Certificate profile not found\n", argv[1]);
return -1;
}else{
if(ecc_api_init()){
return -1;
}
_profileName = cstrdup(cstrlastpathelement(argv[1]));
if(_profileName){
char * p = strrchr(_profileName, '.');
if(p) *p = 0;
}
rc = cxml_handler_parse_stream(&h->h, f);
if (rc == -1){
fprintf(stderr, "%s Profile parsing error\n", argv[1]);
return -1;
}
fclose(f);
ecc_api_done();
}
return 0;
}
Room *load_RoomData(char *filename, unsigned int number, int flags) {
Room *r;
File *f;
int (*load_func)(File *, Room *, int) = NULL;
int version;
if (filename == NULL || !*filename || (r = new_Room()) == NULL)
return NULL;
if ((f = Fopen(filename)) == NULL) {
destroy_Room(r);
return NULL;
}
r->number = number;
version = fileformat_version(f);
switch(version) {
case -1:
log_err("load_RoomData(): error trying to determine file format version of %s", filename);
load_func = NULL;
break;
case 0:
Frewind(f);
load_func = load_RoomData_version0;
break;
case 1:
load_func = load_RoomData_version1;
break;
default:
log_err("load_RoomData(): don't know how to load version %d of %s", version, filename);
}
if (load_func != NULL && !load_func(f, r, flags)) {
Fclose(f);
r->flags &= ROOM_ALL;
/*
force the room name for Mail> and Home>
so that find_abbrevRoom() won't act strangely when these names are different in the files
for some strange reason
*/
if (r->number == MAIL_ROOM) {
Free(r->name);
r->name = cstrdup("Mail");
}
if (r->number == HOME_ROOM) {
Free(r->name);
r->name = cstrdup("Home");
}
if (r->number == MAIL_ROOM)
r->max_msgs = PARAM_MAX_MAIL_MSGS;
else
if (r->max_msgs < 1)
r->max_msgs = PARAM_MAX_MESSAGES;
if (PARAM_HAVE_CHATROOMS && (r->flags & ROOM_CHATROOM) && r->chat_history == NULL)
r->chat_history = new_StringQueue();
if (!PARAM_HAVE_CHATROOMS && (r->flags & ROOM_CHATROOM) && r->number != HOME_ROOM) {
r->flags &= ~ROOM_CHATROOM;
r->flags |= ROOM_DIRTY;
}
(void)sort_StringList(&r->room_aides, alphasort_StringList);
(void)sort_StringList(&r->invited, alphasort_StringList);
(void)sort_StringList(&r->kicked, alphasort_StringList);
return r;
}
destroy_Room(r);
Fclose(f);
return NULL;
}
int load_RoomData_version0(File *f, Room *r, int flags) {
char buf[MAX_LONGLINE];
StringList *sl;
int i;
/* name */
if (Fgets(f, buf, MAX_LINE) == NULL)
goto err_load_room;
cstrip_line(buf);
Free(r->name);
r->name = cstrdup(buf);
if (flags & LOAD_ROOM_DATA) {
/* generation/creation date */
if (Fgets(f, buf, MAX_LINE) == NULL)
goto err_load_room;
cstrip_line(buf);
r->generation = cstrtoul(buf, 10);
/* flags */
if (Fgets(f, buf, MAX_LINE) == NULL)
goto err_load_room;
cstrip_line(buf);
r->flags = (unsigned int)cstrtoul(buf, 16);
r->flags &= ROOM_ALL; /* reset non-existant flags */
/* roominfo_changed */
if (Fgets(f, buf, MAX_LINE) == NULL)
goto err_load_room;
cstrip_line(buf);
r->roominfo_changed = (unsigned int)cstrtoul(buf, 10);
} else
LOAD_ROOM_SKIPLINES(3);
/* info */
destroy_StringIO(r->info);
r->info = NULL;
if (PARAM_HAVE_RESIDENT_INFO || (flags & LOAD_ROOM_INFO)) {
while(Fgets(f, buf, MAX_LINE) != NULL) {
if (!*buf)
break;
if (r->info == NULL && (r->info = new_StringIO()) == NULL)
continue;
put_StringIO(r->info, buf);
write_StringIO(r->info, "\n", 1);
}
} else
LOAD_ROOM_SKIPLIST;
/* room aides */
listdestroy_StringList(r->room_aides);
r->room_aides = NULL;
if (flags & LOAD_ROOM_AIDES) {
while(Fgets(f, buf, MAX_LINE) != NULL) {
cstrip_line(buf);
if (!*buf)
break;
if (user_exists(buf) && (sl = new_StringList(buf)) != NULL)
r->room_aides = add_StringList(&r->room_aides, sl);
}
r->room_aides = rewind_StringList(r->room_aides);
} else
LOAD_ROOM_SKIPLIST;
/* invited */
listdestroy_StringList(r->invited);
r->invited = NULL;
if (flags & LOAD_ROOM_INVITED) {
while(Fgets(f, buf, MAX_LINE) != NULL) {
cstrip_line(buf);
if (!*buf)
break;
if (user_exists(buf) && (sl = new_StringList(buf)) != NULL)
r->invited = add_StringList(&r->invited, sl);
}
r->invited = rewind_StringList(r->invited);
} else
LOAD_ROOM_SKIPLIST;
/* kicked */
listdestroy_StringList(r->kicked);
r->kicked = NULL;
if (flags & LOAD_ROOM_KICKED) {
while(Fgets(f, buf, MAX_LINE) != NULL) {
cstrip_line(buf);
if (!*buf)
break;
if (user_exists(buf) && (sl = new_StringList(buf)) != NULL)
r->kicked = add_StringList(&r->kicked, sl);
}
r->kicked = rewind_StringList(r->kicked);
} else
LOAD_ROOM_SKIPLIST;
/* chat history */
if ((flags & LOAD_ROOM_CHAT_HISTORY) && (r->flags & ROOM_CHATROOM)) {
if (r->chat_history == NULL && (r->chat_history = new_StringQueue()) == NULL)
LOAD_ROOM_SKIPLIST;
else {
r->chat_history->tail = (ListType *)Fgetlist(f);
r->chat_history->head = (ListType *)unwind_StringList((StringList *)r->chat_history->tail);
r->chat_history->count = count_List(r->chat_history->tail);
}
} else
LOAD_ROOM_SKIPLIST;
return 0;
err_load_room:
return -1;
}
Sym_table *
coff_symbols(Environ *e, uByte *load, uInt loadlen)
{
uByte *image = load;
Fileheader *fhdr;
Bool swap;
Optfileheader *ofhdr;
Sectionheader *scnhdr;
Syment *sym;
char *strtab;
int i, nsyms, num, sect, numsections;
Sym_table *tab;
/* sanity check */
if (!coff_is_exec(e, load, loadlen))
return NULL;
fhdr = (Fileheader*)image;
swap = (fhdr->magic[0] == COFF_MAGIC_1);
ofhdr = (Optfileheader*)(fhdr + 1);
scnhdr = (Sectionheader*)((uPtr)ofhdr + SWAPSHORT(swap, fhdr->opthdrlen));
nsyms = SWAPINT(swap, fhdr->nsyms);
image += SWAPINT(swap, fhdr->symtab);
strtab = (char*)(image + nsyms * SYMESZ);
numsections = SWAPSHORT(swap, fhdr->sections);
num = 0;
DPRINTF((
"coff_symbols: fhdr=%#x swap=%d nsyms=%d strtab=%#x numsections=%d\n",
fhdr, swap, nsyms, strtab, numsections));
/* first count the number of symbols we need */
for (i = 0; i < nsyms; i++)
{
/* sym may be mis-sized by the compiler */
sym = (struct syment*)(image);
DPRINTF(("coff_symbols: i=%d sym=%#x", i, sym));
sect = SWAPSHORT(swap, sym->n_scnum);
DPRINTF((" scnum=%d", sect));
if (sect >= 0 && sect < numsections)
num++;
DPRINTF((" num=%d\n", num));
image += SYMESZ * (sym->n_numaux + 1);
}
DPRINTF(("coff_symbols: num=%d\n", num));
/* allocate space for the symbols */
tab = (Sym_table*)malloc(sizeof *tab);
if (tab == NULL)
return NULL;
memset(tab, 0, sizeof *tab);
tab->list = (Sym_ent*)malloc(sizeof *tab->list * num);
if (tab->list == NULL)
{
free(tab);
return NULL;
}
num = 0;
image = load + SWAPINT(swap, fhdr->symtab);
for (i = 0; i < nsyms; i++)
{
/* sym may be mis-sized by the compiler */
sym = (struct syment*)(image);
sect = SWAPSHORT(swap, sym->n_scnum);
if (sect >= 0 && sect < numsections)
{
if (sym->n_zeroes) /* old-style symbol */
{
tab->list[num].name = lstrdup(sym->n_name,
sym->n_name[7] ? 8 : strlen(sym->n_name));
}
else /* symbol is in string table */
{
tab->list[num].name = strtab + SWAPINT(swap, sym->n_offset);
tab->list[num].name = cstrdup(tab->list[num].name);
}
tab->list[num].addr = SWAPINT(swap, sym->n_value);
tab->list[num].type = (SWAPSHORT(swap, scnhdr[sect].flags) & S_TEXT)
? SYM_TEXT : SYM_DATA;
DPRINTF(("tab %d: name=%P addr=%#x type=%#x\n", num,
tab->list[num].name,
tab->list[num].addr, tab->list[num].type));
if (*tab->list[num].name)
num++;
else
free(tab->list[num].name);
}
image += SYMESZ * (sym->n_numaux + 1);
}
tab->num = num;
return tab;
}
/*
select the next helper to ask a question
if we previously called for help, go back to the same helper (if available)
helpers are selected in an LRU manner
silent can be GH_SILENT, which means to be silent
*/
User *get_helper(User *usr, int silent) {
User *u;
PList *pl;
char instead[24] = "";
if (usr == NULL || !PARAM_HAVE_QUESTIONS)
return NULL;
if (usr->question_asked != NULL) {
for(pl = (PList *)helpers.tail; pl != NULL; pl = pl->next) {
u = (User *)pl->p;
if (!strcmp(u->name, usr->name))
continue;
if (!strcmp(usr->question_asked, u->name)) {
(void)remove_PQueue(&helpers, pl);
if (!(u->flags & USR_HELPING_HAND) || u->total_time / SECS_IN_DAY < PARAM_HELPER_AGE) {
u->flags &= ~USR_HELPING_HAND;
destroy_PList(pl);
break;
}
(void)add_PQueue(&helpers, pl);
if (!silent)
Print(usr, "<green>The question goes to <yellow>%s\n", usr->question_asked);
return u;
}
}
Print(usr, "<yellow>%s<red> is no longer available to help you\n", usr->question_asked);
Free(usr->question_asked);
usr->question_asked = NULL;
strcpy(instead, " <green>instead");
}
while(count_Queue(&helpers) > 0) {
if ((pl = pop_PQueue(&helpers)) == NULL) {
Put(usr, "<red>Sorry, but currently there is no one available to help you\n");
return NULL;
}
u = (User *)pl->p;
if (!u->name[0] || !(u->flags & USR_HELPING_HAND) || u->total_time / SECS_IN_DAY < PARAM_HELPER_AGE) {
u->flags &= ~USR_HELPING_HAND;
destroy_PList(pl);
continue;
}
(void)add_PQueue(&helpers, pl);
if (!strcmp(u->name, usr->name)) {
if (count_Queue(&helpers) > 1)
continue;
Put(usr, "<red>Sorry, but currently there is no one available to help you\n");
return NULL;
}
Free(usr->question_asked);
usr->question_asked = cstrdup(u->name);
if (!silent || instead[0])
Print(usr, "<green>The question goes to <yellow>%s%s\n", usr->question_asked, instead);
return u;
}
Put(usr, "<red>Sorry, but currently there is no one available to help you\n");
return NULL;
}
int BC_Resources::init_fontconfig(const char *search_path)
{
if( fontlist ) return 0;
fontlist = new ArrayList<BC_FontEntry*>;
#define get_str(str,sep,ptr,cond) do { char *out = str; \
while( *ptr && !strchr(sep,*ptr) && (cond) ) *out++ = *ptr++; \
*out = 0; \
} while(0)
#define skip_str(sep, ptr) do { \
while( *ptr && strchr(sep,*ptr) ) ++ptr; \
} while(0)
char find_command[BCTEXTLEN];
sprintf(find_command,
"find %s -name 'fonts.dir' -print -exec cat {} \\;",
search_path);
FILE *in = popen(find_command, "r");
FT_Library freetype_library = 0;
// FT_Face freetype_face = 0;
// FT_Init_FreeType(&freetype_library);
char line[BCTEXTLEN], current_dir[BCTEXTLEN];
current_dir[0] = 0;
while( !feof(in) && fgets(line, BCTEXTLEN, in) ) {
if(!strlen(line)) break;
char *in_ptr = line;
// Get current directory
if(line[0] == '/') {
get_str(current_dir, "\n", in_ptr,1);
for( int i=strlen(current_dir); --i>=0 && current_dir[i]!='/'; )
current_dir[i] = 0;
continue;
}
//printf("TitleMain::build_fonts %s\n", line);
BC_FontEntry *entry = new BC_FontEntry;
char string[BCTEXTLEN];
// Path
get_str(string, "\n", in_ptr, in_ptr[0]!=' ' || in_ptr[1]!='-');
entry->path = cstrcat(2, current_dir, string);
// Foundary
skip_str(" -", in_ptr);
get_str(string, " -\n", in_ptr, 1);
if( !string[0] ) { delete entry; continue; }
entry->foundry = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Family
get_str(string, "-\n", in_ptr, 1);
if( !string[0] ) { delete entry; continue; }
entry->family = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Weight
get_str(string, "-\n", in_ptr, 1);
entry->weight = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Slant
get_str(string, "-\n", in_ptr, 1);
entry->slant = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// SWidth
get_str(string, "-\n", in_ptr, 1);
entry->swidth = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Adstyle
get_str(string, "-\n", in_ptr, 1);
entry->adstyle = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// pixelsize
get_str(string, "-\n", in_ptr, 1);
entry->pixelsize = atol(string);
if(*in_ptr == '-') in_ptr++;
// pointsize
get_str(string, "-\n", in_ptr, 1);
entry->pointsize = atol(string);
if(*in_ptr == '-') in_ptr++;
// xres
get_str(string, "-\n", in_ptr, 1);
entry->xres = atol(string);
if(*in_ptr == '-') in_ptr++;
// yres
get_str(string, "-\n", in_ptr, 1);
entry->yres = atol(string);
if(*in_ptr == '-') in_ptr++;
// spacing
get_str(string, "-\n", in_ptr, 1);
entry->spacing = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// avg_width
get_str(string, "-\n", in_ptr, 1);
entry->avg_width = atol(string);
if(*in_ptr == '-') in_ptr++;
// registry
get_str(string, "-\n", in_ptr, 1);
entry->registry = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// encoding
get_str(string, "-\n", in_ptr, 1);
entry->encoding = cstrdup(string);
if(*in_ptr == '-') in_ptr++;
// Add to list
//printf("TitleMain::build_fonts 1 %s\n", entry->path);
// This takes a real long time to do. Instead just take all fonts
// if(!load_freetype_face(freetype_library,
// freetype_face, entry->path) )
// Fix parameters
sprintf(line, "%s (%s)", entry->family, entry->foundry);
entry->displayname = cstrdup(line);
if(!strcasecmp(entry->weight, "demibold")) {
entry->fixed_style |= BC_FONT_BOLD;
entry->style |= FL_WEIGHT_DEMIBOLD;
}
else if(!strcasecmp(entry->weight, "bold")) {
entry->fixed_style |= BC_FONT_BOLD;
entry->style |= FL_WEIGHT_BOLD;
}
else {
entry->style |= FL_WEIGHT_NORMAL;
}
if(!strcasecmp(entry->slant, "r")) {
entry->style |= FL_SLANT_ROMAN;
}
else if(!strcasecmp(entry->slant, "i")) {
entry->style |= FL_SLANT_ITALIC;
entry->fixed_style |= BC_FONT_ITALIC;
}
else if(!strcasecmp(entry->slant, "o")) {
entry->style |= FL_SLANT_OBLIQUE;
entry->fixed_style |= BC_FONT_ITALIC;
}
if(!strcasecmp(entry->swidth, "normal"))
entry->style = FL_WIDTH_NORMAL;
else if(!strcasecmp(entry->swidth, "ultracondensed"))
entry->style = FL_WIDTH_ULTRACONDENSED;
else if(!strcasecmp(entry->swidth, "extracondensed"))
entry->style = FL_WIDTH_EXTRACONDENSED;
else if(!strcasecmp(entry->swidth, "condensed"))
entry->style = FL_WIDTH_CONDENSED;
else if(!strcasecmp(entry->swidth, "semicondensed"))
entry->style = FL_WIDTH_SEMICONDENSED;
else if(!strcasecmp(entry->swidth, "semiexpanded"))
entry->style = FL_WIDTH_SEMIEXPANDED;
else if(!strcasecmp(entry->swidth, "expanded"))
entry->style = FL_WIDTH_EXPANDED;
else if(!strcasecmp(entry->swidth, "extraexpanded"))
entry->style = FL_WIDTH_EXTRAEXPANDED;
else if(!strcasecmp(entry->swidth, "ultraexpanded"))
entry->style = FL_WIDTH_ULTRAEXPANDED;
else
entry->style = FL_WIDTH_NORMAL;
fontlist->append(entry);
// printf("TitleMain::build_fonts %s: success\n", entry->path);
//printf("TitleMain::build_fonts 2\n");
}
pclose(in);
// Load all the fonts from fontconfig
FcPattern *pat;
FcFontSet *fs;
FcObjectSet *os;
FcChar8 *family, *file, *foundry, *style, *format;
int slant, spacing, width, weight;
int force_style = 0;
// if you want limit search to TrueType put 1
int limit_to_trutype = 1;
FcConfig *config;
int i;
char tmpstring[BCTEXTLEN];
if(!FcInit())
return 1;
config = FcConfigGetCurrent();
FcConfigSetRescanInterval(config, 0);
pat = FcPatternCreate();
os = FcObjectSetBuild ( FC_FAMILY, FC_FILE, FC_FOUNDRY, FC_WEIGHT,
FC_WIDTH, FC_SLANT, FC_FONTFORMAT, FC_SPACING, FC_STYLE, (char *) 0);
FcPatternAddBool(pat, FC_SCALABLE, true);
if(language[0]) {
char langstr[LEN_LANG * 3];
strcpy(langstr, language);
if(region[0]) {
strcat(langstr, "-");
strcat(langstr, region);
}
FcLangSet *ls = FcLangSetCreate();
if(FcLangSetAdd(ls, (const FcChar8*)langstr))
if(FcPatternAddLangSet(pat, FC_LANG, ls))
FcLangSetDestroy(ls);
}
fs = FcFontList(config, pat, os);
FcPatternDestroy(pat);
FcObjectSetDestroy(os);
for (i = 0; fs && i < fs->nfont; i++) {
FcPattern *font = fs->fonts[i];
force_style = 0;
FcPatternGetString(font, FC_FONTFORMAT, 0, &format);
//on this point you can limit font search
if(limit_to_trutype && strcmp((char *)format, "TrueType"))
continue;
sprintf(tmpstring, "%s", format);
BC_FontEntry *entry = new BC_FontEntry;
if(FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch) {
entry->path = cstrdup((char*)file);
}
if(FcPatternGetString(font, FC_FOUNDRY, 0, &foundry) == FcResultMatch) {
entry->foundry = cstrdup((char*)foundry);
}
if(FcPatternGetInteger(font, FC_WEIGHT, 0, &weight) == FcResultMatch) {
switch(weight) {
case FC_WEIGHT_THIN:
case FC_WEIGHT_EXTRALIGHT:
case FC_WEIGHT_LIGHT:
case FC_WEIGHT_BOOK:
force_style = 1;
entry->weight = cstrdup("medium");
break;
case FC_WEIGHT_NORMAL:
case FC_WEIGHT_MEDIUM:
default:
entry->weight = cstrdup("medium");
break;
case FC_WEIGHT_BLACK:
case FC_WEIGHT_SEMIBOLD:
case FC_WEIGHT_BOLD:
entry->weight = cstrdup("bold");
entry->fixed_style |= BC_FONT_BOLD;
break;
case FC_WEIGHT_EXTRABOLD:
case FC_WEIGHT_EXTRABLACK:
force_style = 1;
entry->weight = cstrdup("bold");
entry->fixed_style |= BC_FONT_BOLD;
break;
}
}
if(FcPatternGetString(font, FC_FAMILY, 0, &family) == FcResultMatch)
entry->family = cstrdup((char*)family);
if(FcPatternGetInteger(font, FC_SLANT, 0, &slant) == FcResultMatch) {
switch(slant) {
case FC_SLANT_ROMAN:
default:
entry->slant = cstrdup("r");
entry->style |= FL_SLANT_ROMAN;
break;
case FC_SLANT_ITALIC:
entry->slant = cstrdup("i");
entry->style |= FL_SLANT_ITALIC;
entry->fixed_style |= BC_FONT_ITALIC;
break;
case FC_SLANT_OBLIQUE:
entry->slant = cstrdup("o");
entry->style |= FL_SLANT_OBLIQUE;
entry->fixed_style |= BC_FONT_ITALIC;
break;
}
}
if(FcPatternGetInteger(font, FC_WIDTH, 0, &width) == FcResultMatch) {
switch(width) {
case FC_WIDTH_ULTRACONDENSED:
entry->swidth = cstrdup("ultracondensed");
break;
case FC_WIDTH_EXTRACONDENSED:
entry->swidth = cstrdup("extracondensed");
break;
case FC_WIDTH_CONDENSED:
entry->swidth = cstrdup("condensed");
break;
case FC_WIDTH_SEMICONDENSED:
entry->swidth = cstrdup("semicondensed");
break;
case FC_WIDTH_NORMAL:
default:
entry->swidth = cstrdup("normal");
break;
case FC_WIDTH_SEMIEXPANDED:
entry->swidth = cstrdup("semiexpanded");
break;
case FC_WIDTH_EXPANDED:
entry->swidth = cstrdup("expanded");
break;
case FC_WIDTH_EXTRAEXPANDED:
entry->swidth = cstrdup("extraexpanded");
break;
case FC_WIDTH_ULTRAEXPANDED:
entry->swidth = cstrdup("ultraexpanded");
break;
}
}
if(FcPatternGetInteger(font, FC_SPACING, 0, &spacing) == FcResultMatch) {
switch(spacing) {
case 0:
default:
entry->spacing = cstrdup("p");
break;
case 90:
entry->spacing = cstrdup("d");
break;
case 100:
entry->spacing = cstrdup("m");
break;
case 110:
entry->spacing = cstrdup("c");
break;
}
}
// Add fake stuff for compatibility
entry->adstyle = cstrdup(" ");
entry->pixelsize = 0;
entry->pointsize = 0;
entry->xres = 0;
entry->yres = 0;
entry->avg_width = 0;
entry->registry = cstrdup("utf");
entry->encoding = cstrdup("8");
if(!FcPatternGetString(font, FC_STYLE, 0, &style) == FcResultMatch)
force_style = 0;
// If font has a style unmanaged by titler plugin, force style to be displayed on name
// in this way we can shown all available fonts styles.
if(force_style) {
sprintf(tmpstring, "%s (%s)", entry->family, style);
entry->displayname = cstrdup(tmpstring);
}
else {
if(strcmp(entry->foundry, "unknown")) {
sprintf(tmpstring, "%s (%s)", entry->family, entry->foundry);
entry->displayname = cstrdup(tmpstring);
}
else {
sprintf(tmpstring, "%s", entry->family);
entry->displayname = cstrdup(tmpstring);
}
}
fontlist->append(entry);
}
FcFontSetDestroy(fs);
if(freetype_library)
FT_Done_FreeType(freetype_library);
// for(int i = 0; i < fonts->total; i++)
// fonts->values[i]->dump();
FcConfigAppFontAddDir(0, (const FcChar8*)search_path);
FcConfigSetRescanInterval(0, 0);
os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_FOUNDRY, FC_WEIGHT,
FC_WIDTH, FC_SLANT, FC_SPACING, FC_STYLE, (char *)0);
pat = FcPatternCreate();
FcPatternAddBool(pat, FC_SCALABLE, true);
if(language[0])
{
char langstr[LEN_LANG * 3];
strcpy(langstr, language);
if(region[0])
{
strcat(langstr, "-");
strcat(langstr, region);
}
FcLangSet *ls = FcLangSetCreate();
if(FcLangSetAdd(ls, (const FcChar8*)langstr))
if(FcPatternAddLangSet(pat, FC_LANG, ls))
FcLangSetDestroy(ls);
}
fs = FcFontList(0, pat, os);
FcPatternDestroy(pat);
FcObjectSetDestroy(os);
for(int i = 0; i < fs->nfont; i++)
{
FcPattern *font = fs->fonts[i];
BC_FontEntry *entry = new BC_FontEntry;
FcChar8 *strvalue;
if(FcPatternGetString(font, FC_FILE, 0, &strvalue) == FcResultMatch)
{
entry->path = new char[strlen((char*)strvalue) + 1];
strcpy(entry->path, (char*)strvalue);
}
if(FcPatternGetString(font, FC_FOUNDRY, 0, &strvalue) == FcResultMatch)
{
entry->foundry = new char[strlen((char*)strvalue) + 1];
strcpy(entry->foundry, (char *)strvalue);
}
if(FcPatternGetString(font, FC_FAMILY, 0, &strvalue) == FcResultMatch)
{
entry->family = new char[strlen((char*)strvalue) + 2];
strcpy(entry->family, (char*)strvalue);
}
int intvalue;
if(FcPatternGetInteger(font, FC_SLANT, 0, &intvalue) == FcResultMatch)
{
switch(intvalue)
{
case FC_SLANT_ROMAN:
default:
entry->style |= FL_SLANT_ROMAN;
break;
case FC_SLANT_ITALIC:
entry->style |= FL_SLANT_ITALIC;
break;
case FC_SLANT_OBLIQUE:
entry->style |= FL_SLANT_OBLIQUE;
break;
}
}
if(FcPatternGetInteger(font, FC_WEIGHT, 0, &intvalue) == FcResultMatch)
{
switch(intvalue)
{
case FC_WEIGHT_THIN:
entry->style |= FL_WEIGHT_THIN;
break;
case FC_WEIGHT_EXTRALIGHT:
entry->style |= FL_WEIGHT_EXTRALIGHT;
break;
case FC_WEIGHT_LIGHT:
entry->style |= FL_WEIGHT_LIGHT;
break;
case FC_WEIGHT_BOOK:
entry->style |= FL_WEIGHT_BOOK;
break;
case FC_WEIGHT_NORMAL:
default:
entry->style |= FL_WEIGHT_NORMAL;
break;
case FC_WEIGHT_MEDIUM:
entry->style |= FL_WEIGHT_MEDIUM;
break;
case FC_WEIGHT_DEMIBOLD:
entry->style |= FL_WEIGHT_DEMIBOLD;
break;
case FC_WEIGHT_BOLD:
entry->style |= FL_WEIGHT_BOLD;
break;
case FC_WEIGHT_EXTRABOLD:
entry->style |= FL_WEIGHT_EXTRABOLD;
break;
case FC_WEIGHT_BLACK:
entry->style |= FL_WEIGHT_BLACK;
break;
case FC_WEIGHT_EXTRABLACK:
entry->style |= FL_WEIGHT_EXTRABLACK;
break;
}
}
if(FcPatternGetInteger(font, FC_WIDTH, 0, &intvalue) == FcResultMatch)
{
switch(intvalue)
{
case FC_WIDTH_ULTRACONDENSED:
entry->style |= FL_WIDTH_ULTRACONDENSED;
break;
case FC_WIDTH_EXTRACONDENSED:
entry->style |= FL_WIDTH_EXTRACONDENSED;
break;
case FC_WIDTH_CONDENSED:
entry->style |= FL_WIDTH_CONDENSED;
break;
case FC_WIDTH_SEMICONDENSED:
entry->style = FL_WIDTH_SEMICONDENSED;
break;
case FC_WIDTH_NORMAL:
default:
entry->style |= FL_WIDTH_NORMAL;
break;
case FC_WIDTH_SEMIEXPANDED:
entry->style |= FL_WIDTH_SEMIEXPANDED;
break;
case FC_WIDTH_EXPANDED:
entry->style |= FL_WIDTH_EXPANDED;
break;
case FC_WIDTH_EXTRAEXPANDED:
entry->style |= FL_WIDTH_EXTRAEXPANDED;
break;
case FC_WIDTH_ULTRAEXPANDED:
entry->style |= FL_WIDTH_ULTRAEXPANDED;
break;
}
}
if(FcPatternGetInteger(font, FC_SPACING, 0, &intvalue) == FcResultMatch)
{
switch(intvalue)
{
case FC_PROPORTIONAL:
default:
entry->style |= FL_PROPORTIONAL;
break;
case FC_DUAL:
entry->style |= FL_DUAL;
break;
case FC_MONO:
entry->style |= FL_MONO;
break;
case FC_CHARCELL:
entry->style |= FL_CHARCELL;
break;
}
}
if(entry->foundry && strcmp(entry->foundry, "unknown"))
{
char tempstr[BCTEXTLEN];
sprintf(tempstr, "%s (%s)", entry->family, entry->foundry);
entry->displayname = new char[strlen(tempstr) + 1];
strcpy(entry->displayname, tempstr);
}
else
{
entry->displayname = new char[strlen(entry->family) + 1];
strcpy(entry->displayname, entry->family);
}
fontlist->append(entry);
}
FcFontSetDestroy(fs);
return 0;
}
Sym_table *
elf_symbols(Environ *e, uByte *load, uInt loadlen)
{
Elf32_Ehdr *hdr = (Elf32_Ehdr*)load;
Elf32_Shdr *shdr;
Elf32_Shdr *symtab = NULL;
Elf32_Shdr *strhdr = NULL;
char *strtab;
int i = 0;
int num, nsyms;
char *strs;
Elf32_Sym *syms, *s;
Sym_table *tab;
if (!elf_is_exec(e, load, loadlen)) /* sanity check */
return NULL;
shdr = (Elf32_Shdr*)(load + hdr->e_shoff);
strtab = (char*)load + shdr[hdr->e_shstrndx].sh_offset;
for (i = 0; i < hdr->e_shnum; i++)
{
if (strcmp(strtab + shdr[i].sh_name, ELF_SYMTAB) == 0)
symtab = shdr + i;
else if (strcmp(strtab + shdr[i].sh_name, ELF_STRTAB) == 0)
strhdr = shdr + i;
}
if (symtab == NULL || strhdr == NULL)
return NULL;
if (symtab->sh_entsize != sizeof *syms)
return NULL;
strs = (char*)load + strhdr->sh_offset;
s = syms = (Elf32_Sym*)(load + symtab->sh_offset);
nsyms = symtab->sh_size / sizeof *syms;
num = 0;
/* first count the number of symbols we are interested in */
for (i = 0; i < nsyms; i++, s++)
{
if ((ELF32_ST_BIND(s->st_info) == STB_GLOBAL ||
ELF32_ST_BIND(s->st_info) == STB_LOCAL) &&
(ELF32_ST_TYPE(s->st_info) == STT_OBJECT ||
ELF32_ST_TYPE(s->st_info) == STT_FUNC))
num++;
}
/* allocate space for the symbols */
tab = (Sym_table*)malloc(sizeof *tab);
if (tab == NULL)
return NULL;
memset(tab, 0, sizeof *tab);
tab->list = (Sym_ent*)malloc(sizeof *tab->list * num);
if (tab->list == NULL)
{
free(tab);
return NULL;
}
tab->num = num;
num = 0;
s = syms = (Elf32_Sym*)(load + symtab->sh_offset);
/* and load the table */
for (i = 0; i < nsyms; i++, s++)
{
if ((ELF32_ST_BIND(s->st_info) == STB_GLOBAL ||
ELF32_ST_BIND(s->st_info) == STB_LOCAL) &&
(ELF32_ST_TYPE(s->st_info) == STT_OBJECT ||
ELF32_ST_TYPE(s->st_info) == STT_FUNC))
{
tab->list[num].name = cstrdup(strs + s->st_name);
tab->list[num].addr = s->st_value;
tab->list[num].type = ELF32_ST_TYPE(s->st_info) == STT_FUNC ?
SYM_TEXT : SYM_DATA;
DPRINTF(("tab %d: name=%P addr=%#x type=%#x\n", num,
tab->list[num].name,
tab->list[num].addr, tab->list[num].type));
num++;
}
}
return tab;
}
