static char *
PrefOptCompletionFunction(const char *text, int state)
{
char *cp;
size_t textlen;
int i, matches;
if (state >= gNumPrefOpts)
return (NULL);
textlen = strlen(text);
if (textlen == 0) {
cp = StrDup(gPrefOpts[state].varname);
} else {
cp = NULL;
for (i=0, matches=0; i<gNumPrefOpts; i++) {
if (ISTRNCMP(gPrefOpts[i].varname, text, textlen) == 0) {
if (matches >= state) {
cp = StrDup(gPrefOpts[i].varname);
break;
}
matches++;
}
}
}
return cp;
} /* PrefOptCompletionFunction */
PZNPACTORDATA ZnpActorMakeData(char* dataName, BYTE nDataType, void* data, BYTE dataLen)
{
if (dataName == NULL)
return NULL;
PZNPACTORDATA pData = malloc(sizeof(ZNPACTORDATA));
pData->dataName = StrDup(dataName);
pData->nDataType = nDataType;
switch (nDataType)
{
case ZNP_DATA_TYPE_STRING:
pData->value = (void*)StrDup((char*)data);
break;
case ZNP_DATA_TYPE_INTERGER:
pData->value = malloc(sizeof(int));
memset(pData->value, 0, sizeof(int));
CopyMemory(pData->value, data, dataLen);
break;
case ZNP_DATA_TYPE_FLOAT:
pData->value = malloc(sizeof(double));
memset(pData->value, 0, sizeof(double));
CopyMemory(pData->value, data, dataLen);
break;
default:
free(pData->dataName);
free(pData);
return NULL;
}
return pData;
}
static void
_CheckDBG(
char *name,
DBG_Struct *dbg,
char *red_name)
{
DBG_Struct *red_dbg;
char *src_port, *dsc_port;
char *dbg_dbname = "", *red_dbg_dbname = "";
char *dbname;
ENTER_FUNC;
if ( dbg->redirect != NULL ) {
red_dbg = dbg->redirect;
if ( strcmp(red_dbg->name, red_name ) == 0 ){
src_port = StrDup(StringPort(GetDB_Port(dbg,DB_UPDATE)));
dsc_port = StrDup(StringPort(GetDB_Port(red_dbg,DB_UPDATE)));
if ( ( dbname = GetDB_DBname(dbg,DB_UPDATE) ) != NULL ) {
dbg_dbname = dbname;
}
if ( ( dbname = GetDB_DBname(red_dbg,DB_UPDATE) ) != NULL ) {
red_dbg_dbname = dbname;
}
if ( ( strcmp(dbg->type, red_dbg->type ) == 0 )
&& ( strcmp(dbg_dbname, red_dbg_dbname ) == 0 )
&& ( strcmp(src_port, dsc_port) == 0 ) ) {
Error("The connection destination is same DB");
}
xfree(src_port);
xfree(dsc_port);
}
}
LEAVE_FUNC;
}
void SetDefaultName( CTEXTSTR path, CTEXTSTR name, CTEXTSTR extra )
{
TEXTCHAR *newpath;
size_t len;
static CTEXTSTR filepath;// = GetProgramPath();
static CTEXTSTR filename;// = GetProgramName();
if( path )
{
if( filepath )
Release( (POINTER)filepath );
filepath = StrDup( path );
}
if( name )
{
if( filename )
Release( (POINTER)filename );
filename = StrDup( name );
}
if( !filepath )
filepath = ExpandPath( WIDE("*/") );
if( !filename )
filename = StrDup( GetProgramName() );
if( !filename )
filename = "org.d3x0r.sack";
// this has to come from C heap.. my init isn't done yet probably and
// sharemem will just fai(*syslog_local). (it's probably trying to log... )
newpath = (TEXTCHAR*)malloc( len = sizeof(TEXTCHAR)*(9 + StrLen( filepath ) + StrLen( filename ) + (extra?StrLen(extra):0) + 5) );
#ifdef __cplusplus_cli
tnprintf( newpath, len, WIDE("%s/%s%s.cli.log"), filepath, filename, extra?extra:WIDE("") );
#else
tnprintf( newpath, len, WIDE("%s/%s%s.log"), filepath, filename, extra?extra:WIDE("") );
#endif
gFilename = newpath;//( newpath ); // use the C heap.
//free( newpath ); // get rid of this ...
}
int
HeadData::set_attr(const char *attrName, const char *attrValue)
{
HeadDataNode *it;
assert(attrName != NULL && attrValue != NULL);
for(it = head; it != NULL; it = it->next){
if(strcmp(attrName, it->attrName) == 0)
break;
}
if(it != NULL){
delete[] it->attrValue;
it->attrValue = StrDup(attrValue);
return 0;
}else{
it = new HeadDataNode;
it->attrName = StrDup(attrName);
it->attrValue = StrDup(attrValue);
it->next = head;
head = it;
return 1;
}
};
struct configured_plugin *GetPlugin( CTEXTSTR plugin_mask )
{
struct configured_plugin *plugin;
INDEX idx;
TEXTSTR full_name = StrDup( plugin_mask );
TEXTSTR extra_path = (TEXTSTR)StrChr( plugin_mask, ';' );
if( extra_path )
{
extra_path[0] = 0;
extra_path++;
}
LIST_FORALL( l.plugins, idx, struct configured_plugin*, plugin )
{
if( StrCaseCmp( plugin->plugin_mask, plugin_mask ) == 0 )
break;
}
if( !plugin )
{
plugin = New( struct configured_plugin );
plugin->plugin_full_name = full_name;
plugin->plugin_mask = StrDup( plugin_mask );
plugin->plugin_extra_path = StrDup( extra_path );
plugin->pLoadOn = NULL;
plugin->pNoLoadOn = NULL;
plugin->pli = NULL;
plugin->flags.bDelete = FALSE;
plugin->flags.bLoaded = FALSE;
plugin->flags.bNoLoad = FALSE;
AddLink( &l.plugins, plugin );
}
static char *
BookmarkCompletionFunction(const char *text, int state)
{
char *cp;
size_t textlen;
int i, matches;
if ((gBookmarkTable == NULL) || (state >= gNumBookmarks))
return (NULL);
textlen = strlen(text);
if (textlen == 0) {
cp = StrDup(gBookmarkTable[state].bookmarkName);
} else {
cp = NULL;
for (i=0, matches=0; i<gNumBookmarks; i++) {
if (ISTRNCMP(gBookmarkTable[i].bookmarkName, text, textlen) == 0) {
if (matches >= state) {
cp = StrDup(gBookmarkTable[i].bookmarkName);
break;
}
matches++;
}
}
}
return cp;
} /* BookmarkCompletionFunction */
extern void InitMessage(char *id, char *fn) {
char *tempformat, *tempfn;
#ifdef USE_MSGD
int fd;
Port *port;
#endif
#ifdef USE_SYSLOG
static char buff[SIZE_LOG];
snprintf(buff, SIZE_LOG, "%s/%s", PACKAGE, id);
openlog(buff, LOG_PID, syslog_facility);
#endif
if (fn == NULL) {
tempfn = getenv("LOG_FILE_NAME");
if (tempfn != NULL) {
fn = StrDup(tempfn);
}
}
fpLog = NULL;
Processid = StrDup(id);
tempformat = getenv("LOG_DATA_FORMAT");
if (tempformat != NULL) {
Format = StrDup(tempformat);
}
#ifdef USE_MSGD
if (fn != NULL) {
if (*fn == '@') {
port = ParPort(fn + 1, PORT_MSGD);
if ((fd = ConnectSocket(port, SOCK_STREAM)) >= 0) {
fpLog = SocketToNet(fd);
if (Format == NULL) {
Format = "%F:%i:%f:%L:%B";
}
}
DestroyPort(port);
} else {
if ((fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0600)) >= 0) {
fpLog = FileToNet(fd);
}
}
}
if (fpLog == NULL) {
if (Format == NULL) {
Format = "%Y/%M/%D/%h:%m:%s %F:%f:%L:%B";
}
fpLog = FileToNet(STDOUT_FILENO);
}
#else
if ((fn == NULL) || ((fpLog = fopen(fn, "w+")) == NULL)) {
fpLog = stdout;
}
#endif
if (Format == NULL) {
Format = "%Y/%M/%D/%h:%m:%s %F:%f:%L:%B";
}
MessageFunction = __Message;
}
static uintptr_t CPROC AddPostInstallCommand( uintptr_t psv, arg_list args ) {
PARAM( args, CTEXTSTR, cmd );
PARAM( args, CTEXTSTR, cmd_args );
struct command *command = New( struct command );
command->cmd = StrDup( cmd );
command->args = StrDup( cmd_args );
AddLink( &l.commands, command );
return psv;
}
extern void MCP_RegistHandler(GHashTable *StatusTable, char *status,
char *event, void (*handler)(ProcessNode *)) {
GHashTable *EventTable;
if ((EventTable = g_hash_table_lookup(StatusTable, status)) == NULL) {
EventTable = NewNameHash();
g_hash_table_insert(StatusTable, StrDup(status), EventTable);
}
if (g_hash_table_lookup(EventTable, event) == NULL) {
g_hash_table_insert(EventTable, StrDup(event), handler);
}
}
/* Strip the filename of its prefix and make a new copy.
*/
#ifdef _WIN32
#define PATHSEPCHAR '\\'
#else
#define PATHSEPCHAR '/'
#endif /* _WIN32 */
char *StripPrefix(char *name)
{
char *ptr, *nptr;
if ((ptr = strrchr(name, PATHSEPCHAR)) == NULL)
return StrDup(name);
if (NULL == (nptr = StrDup(ptr+1))) {
nptr = acad_malloc(sizeof(""));
nptr[0] = '\0';
}
return nptr;
}
static void CPROC CheckFiles( uintptr_t psv )
{
INDEX idx;
struct input_file *file;
if( l.flags.bLog )
lprintf( WIDE("Check Files...") );
LIST_FORALL( l.files, idx, struct input_file*, file )
{
FILE *input;
static TEXTCHAR buf[256];
if( l.flags.bLog )
lprintf( WIDE("check %s"), file->filename );
input = sack_fopen( 0, file->filename, WIDE("rt") );
if( input )
{
INDEX var_idx = 0;
while( fgets( buf, sizeof( buf ), input ) )
{
size_t end;
struct variable_tracker *var =(struct variable_tracker*)GetLink( &file->vars, var_idx );
//lprintf( WIDE("buf .. %s"), buf );
while( ( end = strlen(buf) ) && ( buf[end-1] == '\n' ) )
buf[end-1] = 0;
if( l.flags.bLog )
lprintf( WIDE("Content %p %s"), var, buf );
if( !var )
{
TEXTCHAR tmp_name[128];
snprintf( tmp_name, sizeof( tmp_name ), WIDE("<File %s.%d>"), file->varname, var_idx+1 );
var = New( struct variable_tracker );
var->var_content = StrDup( buf );
var->var_name = StrDup( tmp_name );
lprintf( WIDE("Newvar %s=%s"), tmp_name, buf );
var->variable = CreateLabelVariable( tmp_name, LABEL_TYPE_STRING, &var->var_content );
SetLink( &file->vars, var_idx, var );
}
else
{
if( StrCmp( var->var_content, buf ) )
{
Release( var->var_content );
var->var_content = StrDup( buf );
lprintf( WIDE("Change var %s=%s"), var->var_name, buf );
LabelVariableChanged( var->variable );
}
}
var_idx++;
}
sack_fclose( input );
}
static void
addServers( char **srv, int bType )
{
char *name, *class2;
const char *dtx, *cls;
struct display *d;
for (; *srv; srv++) {
if ((cls = strchr( *srv, '_' ))) {
if (!StrNDup( &name, *srv, cls - *srv ))
return;
if (!StrDup( &class2, cls )) {
free( name );
return;
}
} else {
if (!StrDup( &name, *srv ))
return;
class2 = 0;
}
if ((d = FindDisplayByName( name ))) {
if (d->class2)
free( d->class2 );
dtx = "existing";
} else {
if (!(d = NewDisplay( name ))) {
free( name );
if (class2)
free( class2 );
return;
}
dtx = "new";
}
d->stillThere = 1;
d->class2 = class2;
d->displayType = (*name == ':' ? dLocal : dForeign) | bType;
if ((bType & d_lifetime) == dReserve) {
if (d->status == notRunning)
d->status = reserve;
} else {
if (d->status == reserve)
d->status = notRunning;
}
Debug( "found %s %s%s display: %s %s\n", dtx,
((d->displayType & d_location) == dLocal) ? "local" : "foreign",
((d->displayType & d_lifetime) == dReserve) ? " reserve" : "",
d->name, d->class2 );
free( name );
}
}
int
ReadPreamble(char **version, /* version (output) */
char **arch, /* architecture (output) */
long *pre_size, /* preamble size (output) */
long *hdr_size, /* header size (output) */
long *rec_size, /* record size (output) */
FILE *file) /* input file */
{
char buf[PREAM_MAX + 1]; /* input string + null */
/* Check magic number, MAGIC. */
if (!GetLine(buf, 8, file))
return FALSE;
if (strcmp(buf, MAGIC) != 0)
return FALSE;
if (!GetLine(buf, 8, file))
return FALSE;
if (version != NULL)
*version = StrDup(buf);
/* Get architecture. */
if (!GetLine(buf, 8, file))
return FALSE;
if (arch != NULL)
*arch = StrDup(buf);
/* Get preamble size */
if (!GetLong(pre_size, 8, file))
return FALSE;
/* Could check *pre_size here. */
/* Get header size */
if (!GetLong(hdr_size, 8, file))
return FALSE;
/* Get record size */
if (!GetLong(rec_size, 8, file))
return FALSE;
return TRUE; /* success */
}
void DigestCacheSet(DigestCache* self, const char* filename, uint32_t hash, uint64_t timestamp, const HashDigest& digest)
{
ReadWriteLockWrite(&self->m_Lock);
DigestCacheRecord* r;
if (nullptr != (r = (DigestCacheRecord*) HashTableLookup(&self->m_Table, hash, filename)))
{
r->m_Timestamp = timestamp;
r->m_ContentDigest = digest;
r->m_AccessTime = self->m_AccessTime;
}
else
{
r = LinearAllocate<DigestCacheRecord>(&self->m_Allocator);
r->m_Hash = hash;
r->m_ContentDigest = digest;
r->m_Next = nullptr;
r->m_String = StrDup(&self->m_Allocator, filename);
r->m_Timestamp = timestamp;
r->m_AccessTime = self->m_AccessTime;
HashTableInsert(&self->m_Table, r);
}
ReadWriteUnlockWrite(&self->m_Lock);
}
int
Downloader::init_local_file_name(void)
{
int length;
char *tmpStr;
length = task.get_local_dir() ? strlen(task.get_local_dir()) : 1;
length += task.get_local_file() ? strlen(task.get_local_file()) :
strlen(task.url.get_file());
length += 6;
tmpStr = new char[length];
snprintf( tmpStr, length, "%s/%s.mg!",
task.get_local_dir() ? task.get_local_dir() : ".",
task.get_local_file() ? task.get_local_file() :
task.url.get_file() );
delete[] localPath;
delete[] localMg;
tmpStr[length - 5] = '\0';
localPath = StrDup(tmpStr);
tmpStr[length - 5] = '.';
localMg = tmpStr;
return 0;
};
int main( int argc, TEXTCHAR **argv )
{
int saveas = 0;
if( argc < 2 )
{
printf( WIDE("Usage: %s <config filename> [optional - set as config filename]\n" ), argv[0] );
return 1;
}
if( argc > 2 )
saveas = 1;
{
TEXTSTR tmp = (TEXTSTR)StrDup( argv[1] );
TEXTSTR filename = (TEXTSTR)pathrchr( tmp );
if( !filename )
filename = tmp;
{
uint32_t size = 0;
POINTER mem = OpenSpace( NULL, argv[1], &size );
if( mem && size )
{
#ifndef __NO_SQL__
SACK_WriteProfileBlob( WIDE("intershell/configuration" ), saveas?argv[2]:filename, (TEXTCHAR*)mem, size );
#endif
CloseSpace( mem );
}
}
}
return 1;
}
static uintptr_t CPROC SetTeamHelmetSticker( uintptr_t psv, arg_list args )
{
PARAM( args, int64_t, down );
PARAM( args, CTEXTSTR, data );
ffl.helmet_sticker_name[down-1] = StrDup( data );
return psv;
}
static uintptr_t CPROC SetDownIntro( uintptr_t psv, arg_list args )
{
PARAM( args, int64_t, down );
PARAM( args, CTEXTSTR, data );
ffl.downs[down-1] = StrDup( data );
return psv;
}
static char *
CommandCompletionFunction(const char *text, int state)
{
char *cp;
size_t textlen;
int i, matches;
CommandPtr cmdp;
textlen = strlen(text);
if (textlen == 0) {
cp = NULL;
} else {
cp = NULL;
for (i=0, matches=0; ; i++) {
cmdp = GetCommandByIndex(i);
if (cmdp == kNoCommand)
break;
if (ISTRNCMP(cmdp->name, text, textlen) == 0) {
if (matches >= state) {
cp = StrDup(cmdp->name);
break;
}
matches++;
}
}
}
return cp;
} /* CommandCompletionFunction */
static int GetNextInputChar( prompt_slot slot )
/*********************************************/
{
int c;
c = ReadNextChar( slot );
/* Redirect input to a response file; cannot be nested. */
if( c == '@' && !is_quoting ) {
if( CmdFile->how == COMMANDLINE || CmdFile->how == INTERACTIVE ) {
char fname[LINE_BUF_SIZE];
int oi;
for( oi = 0; oi < sizeof( fname ) - 1; ) {
c = ReadNextChar( slot );
if( c == '"' )
is_quoting ^= true;
/* Quit loop if not a valid filename character. */
if( (!is_quoting && (c == ',' || c == '+' || c == ';' || c == ' ')) ||
c == '/' || c < ' ' )
break;
if( c != '"' ) {
fname[oi++] = c;
}
}
fname[oi] = '\0';
if( c > ' ' )
--CmdFile->current;
/* Open the response file and read next character. */
StartNewFile( StrDup( fname ) );
c = ReadNextChar( slot );
}
}
return( c );
}
char *CGTKBase::GetPassword(const char *str)
{
const int windoww = 400;
GtkWidget *dialog = gtk_dialog_new_with_buttons(GetTranslation("Password dialog"), NULL, GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_window_set_default_size(GTK_WINDOW(dialog), windoww, -1);
GtkWidget *label = gtk_label_new(str);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, TRUE, TRUE, 15);
gtk_widget_show(label);
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
GtkWidget *input = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(input), FALSE);
gtk_box_pack_end(GTK_BOX(hbox), input, TRUE, TRUE, 15);
gtk_widget_show(input);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
gtk_widget_show(hbox);
gint dialogret = gtk_dialog_run(GTK_DIALOG(dialog));
char *ret = (dialogret == GTK_RESPONSE_OK) ? StrDup(gtk_entry_get_text(GTK_ENTRY(input))) : NULL;
gtk_widget_destroy(dialog);
return ret;
}
//---------------------------------------------------------------------------
// タイトルの設定
void __fastcall TPrintDlgBox::SetTitle(int col, LPCSTR p)
{
if( col >= COLMAX ) return;
if( col >= mColCount ) mColCount = col + 1;
mTitle[col] = StrDup(p);
if( mWidthP[col] < int(strlen(p)) ) mWidthP[col] = strlen(p);
}
int Insert(HashTable *table, char *name, int index)
{
List *ptr;
int i;
/* lookup entry */
i = hash(table, name);
for (ptr = table->list[i]; ptr != NULL; ptr = ptr->next)
if (strcmp(ptr->entry, name) == 0)
break;
if (ptr == NULL) { /* no entry with "name" was found */
try {
ptr = new List;
ptr->entry = StrDup(name, "entry");
ptr->index = index;
/* put this entry first in the list */
ptr->next = table->list[i];
table->list[i] = ptr;
} catch ( ... ) {
std::cerr << "Not enought memory to insert an item into the hash table";
throw;
}
return (0); /* normal */
} else
return (1); /* name was already found in table */
}
static FunctionMeta* FindFunction(lua_State* L, lua_Debug* ar)
{
// This is slow, it involves string formatting. It's mostly OK, because we're
// careful not to include this in the timings. It will of course affect cache
// and other things. Not that we can make a lot of informed decisions about
// that in an interpreted language anyway.
if (!lua_getinfo(L, "Sn", ar))
Croak("couldn't get debug info for function call");
char buffer[1024];
snprintf(buffer, sizeof(buffer), "%s;%s;%s;%d",
ar->name ? ar->name : "", ar->namewhat ? ar->namewhat : "", ar->source, ar->linedefined);
buffer[(sizeof buffer)-1] = 0;
const uint32_t hash = Djb2Hash(buffer);
HashRecord* r = HashTableLookup(&s_Profiler.m_Functions, hash, buffer);
if (!r) {
r = LinearAllocate<FunctionMeta>(s_Profiler.m_Allocator);
r->m_Hash = hash;
r->m_String = StrDup(s_Profiler.m_Allocator, buffer);
r->m_Next = nullptr;
HashTableInsert(&s_Profiler.m_Functions, r);
}
return static_cast<FunctionMeta*>(r);
}
int GetSysVar(char const *name, Value *val)
{
SysVar *v = FindSysVar(name);
val->type = ERR_TYPE;
if (!v) return E_NOSUCH_VAR;
if (v->type == SPECIAL_TYPE) {
SysVarFunc f = (SysVarFunc) v->value;
return f(0, val);
} else if (v->type == STR_TYPE) {
val->v.str = StrDup(*((char **) v->value));
if (!val->v.str) return E_NO_MEM;
} else {
val->v.val = *((int *) v->value);
}
val->type = v->type;
/* In "verbose" mode, print attempts to test $RunOff */
if (DebugFlag & DB_PRTLINE) {
if (v->value == (void *) &RunDisabled) {
Eprint("(Security note: $RunOff variable tested.)\n");
/* Allow further messages from this line */
FreshLine = 1;
}
}
return OK;
}
static int init_VChan_type (VChan_type* vchan,
char name[],
VChanDataFlows flowType,
void* VChanOwner,
DiscardVChanFptr_type DiscardFptr,
DisconnectVChanFptr_type DisconnectFptr,
VChanStateChangeCBFptr_type VChanStateChangeCBFptr,
VChanIsConnectedFptr_type VChanIsConnectedFptr)
{
// Data
vchan->name = StrDup(name);
if (!vchan->name) return -1;
vchan->dataFlow = flowType;
vchan->isActive = TRUE;
vchan->isOpen = FALSE;
vchan->VChanOwner = VChanOwner;
// Callbacks
vchan->VChanStateChangeCBFptr = VChanStateChangeCBFptr;
// Methods
vchan->DiscardFptr = DiscardFptr;
vchan->DisconnectFptr = DisconnectFptr;
vchan->VChanIsConnectedFptr = VChanIsConnectedFptr;
return 0;
}
char *
Readline(char *prompt)
{
char *linecopy, *line, *cp;
char lbuf[256];
if (gIsTTYr) {
line = getline(prompt);
} else {
line = fgets(lbuf, sizeof(lbuf) - 1, stdin);
if (line != NULL) {
cp = line + strlen(line) - 1;
if (*cp == '\n')
*cp = '\0';
}
}
if (line != NULL) {
if (line[0] == '\0')
return NULL; /* EOF */
linecopy = StrDup(line);
line = linecopy;
}
return (line);
} /* Readline */
Semaphore_t *CreateSem(const char *name, unsigned value)
{
Semaphore_t *sem = Malloc(sizeof(Semaphore_t));
sem->queue.name = StrDup(name);
sem->value = value;
return sem;
}
Monitor_t *
CreateMonitor(const char *name)
{
Monitor_t *mon = Malloc(sizeof(Monitor_t));
mon->queue.name = StrDup(name);
return mon;
}
