bool_t
svcauth_gss_set_svc_name(gss_name_t name)
{
OM_uint32 maj_stat, min_stat;
log_debug("in svcauth_gss_set_svc_name()");
if (_svcauth_gss_name != NULL) {
maj_stat = gss_release_name(&min_stat, &_svcauth_gss_name);
if (maj_stat != GSS_S_COMPLETE) {
log_status("gss_release_name", maj_stat, min_stat);
return (FALSE);
}
_svcauth_gss_name = NULL;
}
maj_stat = gss_duplicate_name(&min_stat, name, &_svcauth_gss_name);
if (maj_stat != GSS_S_COMPLETE) {
log_status("gss_duplicate_name", maj_stat, min_stat);
return (FALSE);
}
return (TRUE);
}
static void log_service_name(gss_ctx_id_t context)
{
OM_uint32 major_status = 0, minor_status = 0;
gss_name_t service_name;
gss_buffer_desc service_name_buffer;
major_status = gss_inquire_context(&minor_status,
context,
NULL,
&service_name,
NULL,
NULL,
NULL,
NULL,
NULL);
if (major_status != GSS_S_COMPLETE) {
log_status("gss_inquire_context", major_status, minor_status);
return;
}
major_status = gss_display_name(&minor_status,
service_name,
&service_name_buffer,
NULL);
if (major_status == GSS_S_COMPLETE) {
LOG_LOGINCONT(log_debug,
"service principal is `%s'",
service_name_buffer.value);
gss_release_buffer(&minor_status, &service_name_buffer);
} else
log_status("gss_display_name", major_status, minor_status);
gss_release_name(&minor_status, &service_name);
}
///
/// Sets the minimum SSL protocol version given a version string
///
/// If None, no change will be made to the SSL context. If version string is invalid or unsupported
/// in this build (see SSL_PROTOCOLS), an error is logged to offer guidance on fixing the problem.
///
/// @param[in,out] ssl_ctx SSL context
/// @param[in] min_version Name of minimum required SSL protocol version, or "None"
/// @returns 1 if successful, otherwise 0
///
int
set_ssl_ctx_min_version(SSL_CTX * ssl_ctx, const char *min_version)
{
int min_version_num = ssl_protocol_from_string(min_version);
switch (min_version_num) {
case 0:
// None specified, no changes needed
return 1;
case -1:
log_status("ERROR: Unknown ssl_min_protocol_version '%s'. Specify one of: %s",
min_version, SSL_KNOWN_PROTOCOLS);
fprintf(stderr,
"ERROR: Unknown ssl_min_protocol_version '%s'. Specify one of: %s\n",
min_version, SSL_KNOWN_PROTOCOLS);
return 0;
case SSL_UNSUPPORTED_PROTOCOL:
log_status("ERROR: ssl_min_protocol_version '%s' not supported by the SSL library "
"in this build. Specify one of: %s",
min_version, SSL_KNOWN_PROTOCOLS);
fprintf(stderr,
"ERROR: ssl_min_protocol_version '%s' not supported by the SSL library "
"in this build. Specify one of: %s\n",
min_version, SSL_KNOWN_PROTOCOLS);
return 0;
default:
log_status("Requiring SSL protocol version '%s' or higher for encrypted connections",
min_version);
#if defined(SSL_CTX_set_min_proto_version)
// Added in OpenSSL >= 1.1.0
// See: https://www.openssl.org/docs/man1.1.0/ssl/SSL_CTX_set_min_proto_version.html
return SSL_CTX_set_min_proto_version(ssl_ctx, min_version_num);
#elif defined(SSL_CTX_set_options)
// Easy way not implemented, manually turn off protocols to match the minimum version.
// FB_*_VERSION macros are guaranteed to be defined regardless of OpenSSL version,
// either as a real version or SSL_UNSUPPORTED_PROTOCOL, which will never be greater
// than min_version_num.
if (min_version_num > FB_SSL3_VERSION)
SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SSLv3);
if (min_version_num > FB_TLS1_VERSION)
SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_TLSv1);
if (min_version_num > FB_TLS1_1_VERSION)
SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_TLSv1_1);
if (min_version_num > FB_TLS1_2_VERSION)
SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_TLSv1_2);
// No need to add newer versions as OpenSSL >= 1.1.0 supports the much-nicer
// SSL_CTX_set_min_proto_version - see above
return 1;
#else
// A minimum version was requested, but the SSL library doesn't support specifying that.
// Error out with some advice.
log_status("ERROR: specifying ssl_min_protocol_version is not supported by the SSL "
"library used in this build. Set to 'None', or maybe use OpenSSL?");
fprintf(stderr,
"specifying ssl_min_protocol_version is not supported by the SSL "
"library used in this build. Set to 'None', or maybe use OpenSSL?\n");
return 0;
#endif
}
}
void
dump_database(void)
{
epoch++;
log_status("DUMPING: %s.#%d#", dumpfile, epoch);
dump_database_internal();
log_status("DUMPING: %s.#%d# (done)", dumpfile, epoch);
}
void
do_shutdown(dbref player)
{
if (Wizard(player)) {
log_status("SHUTDOWN: by %s", unparse_object(player, player));
shutdown_flag = 1;
restart_flag = 0;
} else {
notify(player, "Your delusions of grandeur have been duly noted.");
log_status("ILLEGAL SHUTDOWN: tried by %s", unparse_object(player, player));
}
}
void
do_restart(dbref player)
{
if (Wizard(player) && Typeof(player) == TYPE_PLAYER) {
log_status("SHUTDOWN & RESTART: by %s", unparse_object(player, player));
shutdown_flag = 1;
restart_flag = 1;
} else {
notify(player, "Your delusions of grandeur have been duly noted.");
log_status("ILLEGAL RESTART: tried by %s", unparse_object(player, player));
}
}
int
init_game(const char *infile, const char *outfile)
{
FILE *f;
if ((f = fopen(MACRO_FILE, "rb")) == NULL)
log_status("INIT: Macro storage file %s is tweaked.", MACRO_FILE);
else {
macroload(f);
fclose(f);
}
in_filename = (char *) string_dup(infile);
if ((input_file = fopen(infile, "rb")) == NULL)
return -1;
#ifdef DELTADUMPS
if ((delta_outfile = fopen(DELTAFILE_NAME, "wb")) == NULL)
return -1;
if ((delta_infile = fopen(DELTAFILE_NAME, "rb")) == NULL)
return -1;
#endif
db_free();
init_primitives(); /* init muf compiler */
mesg_init(); /* init mpi interpreter */
SRANDOM(getpid()); /* init random number generator */
tune_load_parmsfile(NOTHING); /* load @tune parms from file */
/* ok, read the db in */
log_status("LOADING: %s", infile);
fprintf(stderr, "LOADING: %s\n", infile);
if (db_read(input_file) < 0)
return -1;
log_status("LOADING: %s (done)", infile);
fprintf(stderr, "LOADING: %s (done)\n", infile);
/* set up dumper */
if (dumpfile)
free((void *) dumpfile);
dumpfile = alloc_string(outfile);
if (!db_conversion_flag) {
/* initialize the _sys/startuptime property */
add_property((dbref) 0, "_sys/startuptime", NULL, (int) time((time_t *) NULL));
add_property((dbref) 0, "_sys/maxpennies", NULL, tp_max_pennies);
add_property((dbref) 0, "_sys/dumpinterval", NULL, tp_dump_interval);
add_property((dbref) 0, "_sys/max_connects", NULL, 0);
}
return 0;
}
/*-------------*/
static int accept_sec_context (gss_ctx_id_t *context, gss_cred_id_t server_creds,
gss_buffer_desc *ticket_buffer, gss_name_t *client_name,
gss_buffer_desc *authenticator_buff)
{
OM_uint32 major_status = 0, minor_status = 0, ret_flags;
/* Initialize autheticator buffer. */
authenticator_buff->length = 0;
authenticator_buff->value = NULL;
LOG(log_debug, logtype_uams, "accept_context: accepting context (ticketlen: %u)",
ticket_buffer->length);
/*
* Try to accept the secondary context using the tocken in ticket_buffer.
* We don't care about the mechanisms used, nor for the time.
* We don't act as a proxy either.
*/
major_status = gss_accept_sec_context( &minor_status, context,
server_creds, ticket_buffer, GSS_C_NO_CHANNEL_BINDINGS,
client_name, NULL, authenticator_buff,
&ret_flags, NULL, NULL );
if (major_status != GSS_S_COMPLETE) {
log_status( "accept_sec_context", major_status, minor_status );
return 1;
}
log_ctx_flags( ret_flags );
return 0;
}
/*-------------*/
static int acquire_credentials (gss_name_t *server_name, gss_cred_id_t *server_creds)
{
OM_uint32 major_status = 0, minor_status = 0;
char *envp;
if ((envp = getenv("KRB5_KTNAME")))
LOG(log_debug, logtype_uams,
"acquire credentials: acquiring credentials (uid = %d, keytab = %s)",
(int)geteuid(), envp);
else
LOG(log_debug, logtype_uams,
"acquire credentials: acquiring credentials (uid = %d) - $KRB5_KTNAME not found in env",
(int)geteuid());
/*
* Acquire credentials usable for accepting context negotiations.
* Credentials are for server_name, have an indefinite lifetime,
* have no specific mechanisms, are to be used for accepting context
* negotiations and are to be placed in server_creds.
* We don't care about the mechanisms or about the time for which they are valid.
*/
major_status = gss_acquire_cred( &minor_status, *server_name,
GSS_C_INDEFINITE, GSS_C_NO_OID_SET, GSS_C_ACCEPT,
server_creds, NULL, NULL );
if (major_status != GSS_S_COMPLETE) {
log_status( "acquire_cred", major_status, minor_status );
return 1;
}
return 0;
}
void platform_set_boot_args()
{
#if CFG_BOOT_ARGUMENT
boot_arg_t *bootarg = (boot_arg_t*)BOOT_ARGUMENT_ADDR;
bootarg->magic = BOOT_ARGUMENT_MAGIC;
bootarg->mode = g_boot_mode;
bootarg->e_flag = sp_check_platform();
bootarg->log_port = CFG_UART_LOG;
bootarg->log_baudrate = CFG_LOG_BAUDRATE;
bootarg->log_enable = (u8)log_status();
bootarg->dram_rank_num = get_dram_rank_nr();
get_dram_rank_size(bootarg->dram_rank_size);
bootarg->boot_reason = g_boot_reason;
bootarg->meta_com_type = (u32)g_meta_com_type;
bootarg->meta_com_id = g_meta_com_id;
bootarg->boot_time = get_timer(g_boot_time);
bootarg->da_info.addr = 0;
bootarg->da_info.arg1 = 0;
bootarg->da_info.arg2 = 0;
print("\n%s boot reason: %d\n", MOD, g_boot_reason);
print("%s boot mode: %d\n", MOD, g_boot_mode);
print("%s META COM%d: %d\n", MOD, bootarg->meta_com_id, bootarg->meta_com_type);
print("%s <0x%x>: 0x%x\n", MOD, &bootarg->e_flag, bootarg->e_flag);
print("%s boot time: %dms\n", MOD, bootarg->boot_time);
#endif
}
/* dbref references on the callstack */
static int
has_refs(dbref program, timequeue ptr)
{
int loop;
if (!ptr) {
log_status("WARNING: has_refs(): NULL ptr passed ! Ignored.");
return 0;
}
if (ptr->typ != TQ_MUF_TYP || !(ptr->fr) ||
Typeof(program) != TYPE_PROGRAM || !(PROGRAM_INSTANCES(program)))
return 0;
for (loop = 1; loop < ptr->fr->caller.top; loop++) {
if (ptr->fr->caller.st[loop] == program)
return 1;
}
for (loop = 0; loop < ptr->fr->argument.top; loop++) {
if (ptr->fr->argument.st[loop].type == PROG_ADD &&
ptr->fr->argument.st[loop].data.addr->progref == program)
return 1;
}
return 0;
}
void
dump_deltas(void)
{
if (time_for_monolithic()) {
fork_and_dump();
deltas_count = 0;
return;
}
epoch++;
log_status("DELT: %s.#%d#\n", dumpfile, epoch);
if (tp_deltadump_warning)
wall_and_flush(tp_dumpdeltas_mesg);
db_write_deltas(delta_outfile);
if (tp_deltadump_warning)
wall_and_flush(tp_dumpdone_mesg);
#ifdef DISKBASE
propcache_hits = 0L;
propcache_misses = 1L;
#endif
host_save();
}
int
unset_source(dbref player, dbref loc, dbref action)
{
dbref oldsrc;
if ((oldsrc = DBFETCH(action)->location) == NOTHING) {
/* old-style, sourceless exit */
if (!member(action, DBFETCH(loc)->exits)) {
return 0;
}
DBSTORE(DBFETCH(player)->location, exits,
remove_first(DBFETCH(DBFETCH(player)->location)->exits,
action));
} else {
switch (Typeof(oldsrc)) {
case TYPE_PLAYER:
case TYPE_ROOM:
case TYPE_THING:
DBSTORE(oldsrc, exits,
remove_first(DBFETCH(oldsrc)->exits, action));
break;
default:
log_status("PANIC: source of action #%d was type: %d.\n",
action, Typeof(oldsrc));
return 0;
/* NOTREACHED */
break;
}
}
return 1;
}
static bool_t
svcauth_gss_import_name(char *service)
{
gss_name_t name;
gss_buffer_desc namebuf;
OM_uint32 maj_stat, min_stat;
log_debug("in svcauth_gss_import_name()");
namebuf.value = service;
namebuf.length = strlen(service);
maj_stat = gss_import_name(&min_stat, &namebuf,
(gss_OID)GSS_C_NT_HOSTBASED_SERVICE, &name);
if (maj_stat != GSS_S_COMPLETE) {
log_status("gss_import_name", maj_stat, min_stat);
return (FALSE);
}
if (svcauth_gss_set_svc_name(name) != TRUE) {
gss_release_name(&min_stat, &name);
return (FALSE);
}
return (TRUE);
}
AUTH *
authgss_create_default(CLIENT *clnt, char *service, struct rpc_gss_sec *sec)
{
AUTH *auth;
OM_uint32 maj_stat = 0, min_stat = 0;
gss_buffer_desc sname;
gss_name_t name;
log_debug("in authgss_create_default()");
sname.value = service;
sname.length = strlen(service);
maj_stat = gss_import_name(&min_stat, &sname,
(gss_OID)gss_nt_service_name,
&name);
if (maj_stat != GSS_S_COMPLETE) {
log_status("gss_import_name", maj_stat, min_stat);
rpc_createerr.cf_stat = RPC_AUTHERROR;
return (NULL);
}
auth = authgss_create(clnt, name, sec);
if (name != GSS_C_NO_NAME)
gss_release_name(&min_stat, &name);
log_debug("authgss_create_default returning auth 0x%08x", auth);
return (auth);
}
static void process_signal(int sig){
int r = 0;
switch(sig) {
case SIGINT:
case SIGQUIT:
case SIGTERM:
case SIGHUP:
r += log_status();
break;
case SIGUSR1:
case SIGUSR2:
log_debug();
/*local_debug();*/
cluster_debug();
return;
default:
LOG_PRINT("Unknown signal received... ignoring");
return;
}
if (!r) {
LOG_DBG("No current cluster logs... safe to exit.");
cleanup_all();
exit(EXIT_SUCCESS);
}
LOG_ERROR("Cluster logs exist. Refusing to exit.");
}
/*
* Gracefully shut the server down.
*/
void
sig_shutdown(int i)
{
log_status("SHUTDOWN: via SIGNAL");
shutdown_flag = 1;
restart_flag = 0;
}
AUTH *
authgss_create_default(CLIENT *clnt, char *service, struct rpc_gss_sec *sec)
{
AUTH *auth;
OM_uint32 maj_stat = 0, min_stat = 0;
gss_buffer_desc sname;
gss_name_t name = GSS_C_NO_NAME;
log_debug("in authgss_create_default()");
sname.value = service;
sname.length = strlen(service);
maj_stat = gss_import_name(&min_stat, &sname,
(gss_OID)GSS_C_NT_HOSTBASED_SERVICE,
&name);
if (maj_stat != GSS_S_COMPLETE) {
log_status("gss_import_name", maj_stat, min_stat);
rpc_createerr.cf_stat = RPC_AUTHERROR;
return (NULL);
}
auth = authgss_create(clnt, name, sec);
if (name != GSS_C_NO_NAME) {
#ifdef DEBUG
fprintf(stderr, "authgss_create_default: freeing name %p\n", name);
#endif
gss_release_name(&min_stat, &name);
}
return (auth);
}
// ----------------------------------------------------------------------------
//
void DMXStudio::showIpAddress()
{
char cpuName [128] ;
DWORD dwSize = sizeof(cpuName);
WSADATA wsaData;
int iResult;
if ( GetComputerName( cpuName, &dwSize) == 0 )
return;
// Initialize Winsock
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (iResult == 0) {
PADDRINFOA pAddrInfo;
iResult = getaddrinfo( cpuName, "http", NULL, &pAddrInfo );
if ( iResult == 0 ) {
for ( PADDRINFOA pAddr=pAddrInfo; pAddr != NULL; pAddr=pAddr->ai_next ) {
if ( AF_INET == pAddr->ai_family ) {
struct sockaddr_in *sockaddr_ipv4;
sockaddr_ipv4 = (struct sockaddr_in *) pAddr->ai_addr;
log_status( "%s IP address %s", cpuName, inet_ntoa(sockaddr_ipv4->sin_addr) );
}
}
freeaddrinfo( pAddrInfo );
}
}
WSACleanup();
}
void
log_program_text(struct line *first, dbref player, dbref i)
{
FILE *f;
char fname[BUFFER_LEN];
time_t lt = time(NULL);
strcpyn(fname, sizeof(fname), PROGRAM_LOG);
f = fopen(fname, "ab");
if (!f) {
log_status("Couldn't open file %s!", fname);
return;
}
fputs("#######################################", f);
fputs("#######################################\n", f);
fprintf(f, "PROGRAM %s, SAVED AT %s BY %s(%d)\n",
unparse_object(player, i), ctime(<), NAME(player), player);
fputs("#######################################", f);
fputs("#######################################\n\n", f);
while (first) {
if (!first->this_line)
continue;
fputs(first->this_line, f);
fputc('\n', f);
first = first->next;
}
fputs("\n\n\n", f);
fclose(f);
}
void
write_program(struct line *first, dbref i)
{
FILE *f;
char fname[BUFFER_LEN];
snprintf(fname, sizeof(fname), "muf/%d.m", (int) i);
f = fopen(fname, "wb");
if (!f) {
log_status("Couldn't open file %s!", fname);
return;
}
while (first) {
if (!first->this_line)
continue;
if (fputs(first->this_line, f) == EOF) {
abort();
}
if (fputc('\n', f) == EOF) {
abort();
}
first = first->next;
}
fclose(f);
}
bool_t
svcauth_gss_nextverf(struct svc_req *rqst, u_int num)
{
struct svc_rpc_gss_data *gd;
gss_buffer_desc signbuf, checksum;
OM_uint32 maj_stat, min_stat;
log_debug("in svcauth_gss_nextverf()");
if (rqst->rq_xprt->xp_auth == NULL)
return (FALSE);
gd = SVCAUTH_PRIVATE(rqst->rq_xprt->xp_auth);
signbuf.value = #
signbuf.length = sizeof(num);
maj_stat = gss_get_mic(&min_stat, gd->ctx, gd->sec.qop,
&signbuf, &checksum);
if (maj_stat != GSS_S_COMPLETE) {
log_status("gss_get_mic", maj_stat, min_stat);
return (FALSE);
}
rqst->rq_xprt->xp_verf.oa_flavor = RPCSEC_GSS;
rqst->rq_xprt->xp_verf.oa_base = (caddr_t)checksum.value;
rqst->rq_xprt->xp_verf.oa_length = (u_int)checksum.length;
return (TRUE);
}
void
do_restart(dbref player, const char *msg)
{
if (Arch(player)) {
if( *msg == '\0' || strcmp(msg, tp_muckname))
{
notify(player, "Usage: @restart muckname" );
return;
}
log_status("REST: by %s\n", unparse_object(player, player));
shutdown_flag = 1;
restart_flag = 1;
} else {
anotify_fmt(player, CFAIL "%s", tp_noperm_mesg);
log_status("SHAM: Restart by %s\n", unparse_object(player, player));
}
}
/*
* Gracefully shut the server down.
*/
RETSIGTYPE sig_shutdown(int i)
{
log_status("SHUTDOWN: via SIGNAL");
shutdown_flag = 1;
restart_flag = 0;
#if !defined(SYSV) && !defined(_POSIX_VERSION) && !defined(ULTRIX)
return 0;
#endif
}
/**
* Send status to wizards and log file
*
* @private
* @param s the message to send
*/
static void
wall_status(char *s)
{
char buf[BUFFER_LEN];
log_status(s);
snprintf(buf, sizeof(buf), "## %s", s);
wall_wizards(buf);
}
void CommanderFromFile::Main() {
sleep(30);
if (command_ == NONE) {
FILE *F;
char buf[CR_BUFF_SIZE];
commander_mutex_.Lock();
F = fopen(file_name_.c_str(), "rw");
if(F) {
if(fgets(buf, CR_BUFF_SIZE - 1, F)) {
char* eol = strchr(buf, '\n');
if (eol != NULL) *eol = '\0';
if(strstr(buf, CL_PAUSE)) {
log_status("Setting command to PAUSE.");
command_ = PAUSE;
algo_.SetNumThreads(0);
SetCommand();
} else if(strstr(buf, CL_RESUME)) {
log_status("Setting command to RESUME.");
command_ = RESUME;
algo_.ResumeThreads();
SetCommand();
} else if (strstr(buf, CL_SET_NUM_THREADS)) {
log_status("Setting command to SET_NUM_THREADS.");
command_ = SET_NUM_THREADS;
string tmp = strstr(buf, CL_SET_NUM_THREADS);
if(tmp.length()>=sizeof(CL_SET_NUM_THREADS)) {
attributes_ = tmp.substr(sizeof(CL_SET_NUM_THREADS));
} else {
attributes_ = "";
}
algo_.SetNumThreads(atoi(attributes_.c_str()));
SetCommand();
} else {
log_warn("unknown command.");
}
}
fclose(F);
remove(file_name_.c_str());
}
commander_mutex_.Unlock();
}
}
/* clean up lists from watchpid and sends event */
void
watchpid_process(struct frame *fr)
{
if (!fr) {
log_status("WARNING: watchpid_process(): NULL frame passed ! Ignored.");
return;
}
struct frame *frame;
struct mufwatchpidlist *cur;
struct mufwatchpidlist **curptr;
struct inst temp1;
temp1.type = PROG_INTEGER;
temp1.data.number = fr->pid;
while (fr->waitees) {
cur = fr->waitees;
fr->waitees = cur->next;
frame = timequeue_pid_frame (cur->pid);
free (cur);
if (frame) {
for (curptr = &frame->waiters; *curptr; curptr = &(*curptr)->next) {
if ((*curptr)->pid == fr->pid) {
cur = *curptr;
*curptr = (*curptr)->next;
free (cur);
break;
}
}
}
}
while (fr->waiters) {
char buf[64];
snprintf (buf, sizeof(buf), "PROC.EXIT.%d", fr->pid);
cur = fr->waiters;
fr->waiters = cur->next;
frame = timequeue_pid_frame (cur->pid);
free (cur);
if (frame) {
muf_event_add(frame, buf, &temp1, 0);
for (curptr = &frame->waitees; *curptr; curptr = &(*curptr)->next) {
if ((*curptr)->pid == fr->pid) {
cur = *curptr;
*curptr = (*curptr)->next;
free (cur);
break;
}
}
}
}
}
static int get_client_username(char *username,
int ulen,
gss_name_t *client_name)
{
OM_uint32 major_status = 0, minor_status = 0;
gss_buffer_desc client_name_buffer;
char *p;
int ret = 0;
/*
* To extract the unix username, use gss_display_name on client_name.
* We do rely on gss_display_name returning a zero terminated string.
* The username returned contains the realm and possibly an instance.
* We only want the username for afpd, so we have to strip those from
* the username before copying it to afpd's buffer.
*/
major_status = gss_display_name(&minor_status,
*client_name,
&client_name_buffer,
NULL);
if (major_status != GSS_S_COMPLETE) {
log_status("gss_display_name", major_status, minor_status);
return 1;
}
LOG_LOGINCONT(log_debug,
"user principal is `%s'",
client_name_buffer.value);
/* chop off realm */
p = strchr(client_name_buffer.value, '@');
if (p)
*p = 0;
/* FIXME: chop off instance? */
p = strchr(client_name_buffer.value, '/');
if (p)
*p = 0;
/* check if this username fits into afpd's username buffer */
size_t cnblen = strlen(client_name_buffer.value);
if (cnblen >= ulen) {
/* The username is too long for afpd's buffer, bail out */
LOG_LOGINCONT(log_info,
"username `%s' too long (%d)",
client_name_buffer.value, cnblen);
ret = 1;
} else {
/* copy stripped username to afpd's buffer */
strlcpy(username, client_name_buffer.value, ulen);
}
gss_release_buffer(&minor_status, &client_name_buffer);
return ret;
}
// ----------------------------------------------------------------------------
//
bool DMXStudio::handleEvent( const Event& event )
{
if ( isDebug() ) {
CString output( "EVENT " );
output.Append( (LPCSTR)EventBus::eventAsString( event ) );
log_status( output );
}
if ( event.m_source == ES_VENUE ) {
if ( event.m_action == EA_START )
log_status( "Venue started [%s]", event.m_text );
else if ( event.m_action == EA_STOP )
log_status( "Venue stopped [%s]", event.m_text );
else if ( event.m_action == EA_ERROR )
log( StudioException( event.m_text ) );
}
return false;
}
/*
* Named "fork_and_dump()" mostly for historical reasons...
*/
void fork_and_dump(void)
{
epoch++;
last_monolithic_time = time(NULL);
log_status("DUMP: %s.#%d#\n", dumpfile, epoch);
dump_database_internal();
host_save();
}
