static void
bigg_finalise(void *SXE_UNUSED(header), int for_disksave)
{
if (for_disksave)
signal_simple_error
("Can't dump an emacs containing "
"pseudo-gaussian objects",Qt);
}
static void
bigc_finalise (void *SXE_UNUSED(header), int for_disksave)
{
if (for_disksave)
signal_simple_error
("Can't dump an emacs containing MPC objects",Qt);
return;
}
static void finalize_ldap(void *header, int for_disksave)
{
Lisp_LDAP *ldap = (Lisp_LDAP *) header;
if (for_disksave)
signal_simple_error
("Can't dump an emacs containing LDAP objects",
make_ldap(ldap));
if (ldap->ld)
ldap_unbind(ldap->ld);
ldap->ld = NULL;
}
static void finalize_database(void *header, int for_disksave)
{
Lisp_Database *db = (Lisp_Database *) header;
if (for_disksave) {
Lisp_Object object;
XSETDATABASE(object, db);
signal_simple_error
("Can't dump an emacs containing database objects", object);
}
db->funcs->close(db);
}
static Lisp_Object
mswindows_canonicalize_console_connection (Lisp_Object connection,
Error_behavior errb)
{
/* Do not allow more than one mswindows device, by explicitly
requiring that CONNECTION is nil, the only allowed connection in
Windows. */
if (!NILP (connection))
{
if (ERRB_EQ (errb, ERROR_ME))
signal_simple_error
("Invalid (non-nil) connection for mswindows device/console",
connection);
else
return Qunbound;
}
return Qnil;
}
static void signal_ldap_error(LDAP * ld, LDAPMessage * res, int ldap_err)
{
if (ldap_err <= 0) {
#if defined HAVE_LDAP_PARSE_RESULT
int err;
ldap_err = ldap_parse_result(ld, res,
&err, NULL, NULL, NULL, NULL, 0);
if (ldap_err == LDAP_SUCCESS)
ldap_err = err;
#elif defined HAVE_LDAP_GET_LDERRNO
ldap_err = ldap_get_lderrno(ld, NULL, NULL);
#elif defined HAVE_LDAP_RESULT2ERROR
ldap_err = ldap_result2error(ld, res, 0);
#else
ldap_err = ld->ld_errno;
#endif
}
signal_simple_error("LDAP error",
build_string(ldap_err2string(ldap_err)));
}
EXTERNAL_PROPERTY_LIST_LOOP(list, keyword, value, search_plist)
{
/* Host */
if (EQ (keyword, Qhost))
{
CHECK_STRING (value);
ldap_host = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_host, (char *)XSTRING_DATA (value));
}
/* Filter */
else if (EQ (keyword, Qfilter))
{
CHECK_STRING (value);
ldap_filter = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_filter, (char *)XSTRING_DATA (value));
}
/* Attributes */
else if (EQ (keyword, Qattributes))
{
if (! NILP (value))
{
Lisp_Object attr_left = value;
struct gcpro ngcpro1;
NGCPRO1 (attr_left);
CHECK_CONS (value);
ldap_attributes = alloca ((XINT (Flength (value)) + 1)*sizeof (char *));
for (i=0; !NILP (attr_left); i++) {
CHECK_STRING (XCAR (attr_left));
ldap_attributes[i] = alloca (XSTRING_LENGTH (XCAR (attr_left)) + 1);
strcpy(ldap_attributes[i],
(char *)(XSTRING_DATA( XCAR (attr_left))));
attr_left = XCDR (attr_left);
}
ldap_attributes[i] = NULL;
NUNGCPRO;
}
}
/* Attributes Only */
else if (EQ (keyword, Qattrsonly))
{
CHECK_SYMBOL (value);
ldap_attrsonly = NILP (value) ? 0 : 1;
}
/* Base */
else if (EQ (keyword, Qbase))
{
if (!NILP (value))
{
CHECK_STRING (value);
ldap_base = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_base, (char *)XSTRING_DATA (value));
}
}
/* Scope */
else if (EQ (keyword, Qscope))
{
CHECK_SYMBOL (value);
if (EQ (value, Qbase))
ldap_scope = LDAP_SCOPE_BASE;
else if (EQ (value, Qonelevel))
ldap_scope = LDAP_SCOPE_ONELEVEL;
else if (EQ (value, Qsubtree))
ldap_scope = LDAP_SCOPE_SUBTREE;
else
signal_simple_error ("Invalid scope", value);
}
/* Authentication method */
else if (EQ (keyword, Qauth))
{
CHECK_SYMBOL (value);
if (EQ (value, Qsimple))
ldap_auth = LDAP_AUTH_SIMPLE;
#ifdef LDAP_AUTH_KRBV41
else if (EQ (value, Qkrbv41))
ldap_auth = LDAP_AUTH_KRBV41;
#endif
#ifdef LDAP_AUTH_KRBV42
else if (EQ (value, Qkrbv42))
ldap_auth = LDAP_AUTH_KRBV42;
#endif
else
signal_simple_error ("Invalid authentication method", value);
}
/* Bind DN */
else if (EQ (keyword, Qbinddn))
{
if (!NILP (value))
{
CHECK_STRING (value);
ldap_binddn = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_binddn, (char *)XSTRING_DATA (value));
}
}
/* Password */
else if (EQ (keyword, Qpasswd))
{
if (!NILP (value))
{
CHECK_STRING (value);
ldap_passwd = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_passwd, (char *)XSTRING_DATA (value));
}
}
/* Deref */
else if (EQ (keyword, Qderef))
{
CHECK_SYMBOL (value);
if (EQ (value, Qnever))
ldap_deref = LDAP_DEREF_NEVER;
else if (EQ (value, Qsearch))
ldap_deref = LDAP_DEREF_SEARCHING;
else if (EQ (value, Qfind))
ldap_deref = LDAP_DEREF_FINDING;
else if (EQ (value, Qalways))
ldap_deref = LDAP_DEREF_ALWAYS;
else
signal_simple_error ("Invalid deref value", value);
}
/* Timelimit */
else if (EQ (keyword, Qtimelimit))
{
if (!NILP (value))
{
CHECK_INT (value);
ldap_timelimit = XINT (value);
}
}
/* Sizelimit */
else if (EQ (keyword, Qsizelimit))
{
if (!NILP (value))
{
CHECK_INT (value);
ldap_sizelimit = XINT (value);
}
}
}
