/* -*- mode: C; mode: fold; -*- */ /* Copyright (c) 1995, 1996 John E. Davis (davis@space.mit.edu) * All rights reserved. */ /* Read startup .slrnrc file */ #include "config.h" #include "slrnfeat.h" /*{{{ Include Files */ #include #ifdef HAVE_STDLIB_H # include #endif #include #include #include "jdmacros.h" #include "slrn.h" #include "group.h" #include "misc.h" #include "art.h" #include "post.h" #include "startup.h" #include "score.h" #include "util.h" #include "uudecode.h" #if SLRN_HAS_MIME # include "mime.h" #endif #if SLRN_HAS_GROUPLENS # include "grplens.h" #endif #if SLRN_HAS_SLANG # include "interp.h" #endif #include "server.h" #include "chmap.h" #ifdef VMS # include "vms.h" #endif /*}}}*/ /*{{{ Forward Function Declarations */ static int unsetkey_fun (int, SLcmd_Cmd_Table_Type *); static int setkey_fun (int, SLcmd_Cmd_Table_Type *); static int server_fun (int, SLcmd_Cmd_Table_Type *); static int color_fun (int, SLcmd_Cmd_Table_Type *); static int mono_fun (int, SLcmd_Cmd_Table_Type *); static int user_data_fun (int, SLcmd_Cmd_Table_Type *); static int ignore_quote_fun (int, SLcmd_Cmd_Table_Type *); static int autobaud_fun (int, SLcmd_Cmd_Table_Type *); static int set_variable_fun (int, SLcmd_Cmd_Table_Type *); static int nnrp_fun (int, SLcmd_Cmd_Table_Type *); static int grouplens_fun (int, SLcmd_Cmd_Table_Type *); static int interpret_fun (int, SLcmd_Cmd_Table_Type *); static int include_file_fun (int, SLcmd_Cmd_Table_Type *); /*}}}*/ /*{{{ Static Global Variables */ static int This_Line_Num; /* current line number in startup file */ static char *This_File; static char *This_Line; /* line being parsed */ char *Server_Object; char *Post_Object; static SLcmd_Cmd_Table_Type Slrn_Cmd_Table; static SLcmd_Cmd_Type Slrn_Startup_File_Cmds[] = /*{{{*/ { {unsetkey_fun, "unsetkey", "SS"}, {setkey_fun, "setkey", "SSS"}, {server_fun, "server", "SS"}, {color_fun, "color", "SSS"}, {mono_fun, "mono", "SSsss"}, {set_variable_fun, "set", "SG"}, {user_data_fun, "hostname", "S"}, {nnrp_fun, "nnrpaccess", "SSS" }, #define SLRN_MAX_QUOTE_REGEXP 5 {ignore_quote_fun, "ignore_quotes", "Sssss"}, {autobaud_fun, "autobaud", ""}, {grouplens_fun, "grouplens_add", "S"}, {interpret_fun, "interpret", "S"}, {include_file_fun, "include", "S"}, {user_data_fun, "scorefile", "S"}, /* The following are considered obsolete */ {user_data_fun, "username", "S"}, {user_data_fun, "replyto", "S"}, {user_data_fun, "organization", "S"}, {user_data_fun, "signature", "S"}, {user_data_fun, "realname", "S"}, {user_data_fun, "followup", "S"}, {user_data_fun, "cc_followup_string", "S"}, {user_data_fun, "quote_string", "S"}, #if SLRN_HAS_DECODE {user_data_fun, "decode_directory", "S"}, #endif {user_data_fun, "editor_command", "S"}, {NULL, "", ""} }; /*}}}*/ /*}}}*/ /*{{{ Public Global Variables */ SLRegexp_Type *Slrn_Ignore_Quote_Regexp [SLRN_MAX_QUOTE_REGEXP + 1]; int Slrn_Autobaud = 0; char *Slrn_Score_File; int Slrn_Scroll_By_Page; /*}}}*/ /*{{{ Utility Functions */ static void exit_malloc_error (void) /*{{{*/ { if (This_File == NULL) slrn_exit_error ("Memory Allocation Failure"); slrn_exit_error ("%s: Line %d\n%sMemory Allocation Failure", This_File, This_Line_Num, This_Line); } /*}}}*/ static char *safe_malloc (unsigned int n) /*{{{*/ { char *s; s = (char *) SLMALLOC (n); if (s == NULL) exit_malloc_error (); return s; } /*}}}*/ static void exit_unknown_object (void) /*{{{*/ { slrn_exit_error ("%s: Error encountered processing line %d\n%s", This_File, This_Line_Num, This_Line); } /*}}}*/ static void issue_obsolete_message (void) /*{{{*/ { slrn_message ("%s: Command is obsolete on line %d:\n%s", This_File, This_Line_Num, This_Line); slrn_message ("The new usage is:\nset %s\n", This_Line); } /*}}}*/ /*}}}*/ /*{{{ Set/Unset Key Functions */ static int setkey_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { char *map = table->string_args[1]; char *fun = table->string_args[2]; char *key = table->string_args[3]; SLKeyMap_List_Type *kmap = NULL; (void) argc; if (!strcmp (map, "group")) kmap = Slrn_Group_Keymap; else if (!strcmp (map, "article")) kmap = Slrn_Article_Keymap; else if (!strcmp (map, "readline")) kmap = Slrn_RLine_Keymap; else slrn_exit_error ("%s: line %d:\n%sNo such keymap: %s", This_File, This_Line_Num, This_Line, map); if (SLang_define_key (key, fun, kmap) != 0) { slrn_exit_error ("%s: line %d:\n%serror defining key.", This_File, This_Line_Num, This_Line); } return 0; } /*}}}*/ static int unsetkey_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { char *map = table->string_args[1]; char *key = table->string_args[2]; SLKeyMap_List_Type *kmap = NULL; (void) argc; if (!strcmp (map, "group")) kmap = Slrn_Group_Keymap; else if (!strcmp (map, "article")) kmap = Slrn_Article_Keymap; else slrn_exit_error ("%s: line %d:\n%sNo such keymap: %s", This_File, This_Line_Num, This_Line, map); SLang_undefine_key (key, kmap); return 0; } /*}}}*/ /*}}}*/ static int autobaud_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { (void) argc; (void) table; Slrn_Autobaud = 1; return 0; } /*}}}*/ static SLRegexp_Type *compile_quote_regexp (char *str) /*{{{*/ { unsigned char *compiled_pattern_buf; SLRegexp_Type *r; compiled_pattern_buf = (unsigned char *) safe_malloc (512); r = (SLRegexp_Type *) safe_malloc (sizeof (SLRegexp_Type)); r->pat = (unsigned char *) str; r->buf = compiled_pattern_buf; r->case_sensitive = 1; r->buf_len = 512; if (SLang_regexp_compile (r)) { slrn_exit_error ("%s: line %d:\n%sInvalid regular expression.", This_File, This_Line_Num, This_Line); } return r; } /*}}}*/ static int ignore_quote_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { unsigned int i; SLRegexp_Type *r; if (argc > SLRN_MAX_QUOTE_REGEXP + 1) { slrn_exit_error ("%s: line %d:\n%sToo many expressions specified.", This_File, This_Line_Num, This_Line); } for (i = 0; i < SLRN_MAX_QUOTE_REGEXP; i++) { r = Slrn_Ignore_Quote_Regexp[i]; if (r != NULL) { slrn_free ((char *) r->buf); SLFREE (r); Slrn_Ignore_Quote_Regexp [i] = NULL; } } for (i = 1; i < (unsigned int) argc; i++) { Slrn_Ignore_Quote_Regexp[i - 1] = compile_quote_regexp (table->string_args[i]); } return 0; } /*}}}*/ static int grouplens_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { (void) argc; #if SLRN_HAS_GROUPLENS (void) slrn_grouplens_add_group (table->string_args[1]); #else (void) table; #endif return 0; } /*}}}*/ /*{{{ Setting/Getting Variable Functions */ typedef struct /*{{{*/ { char *what; int *valuep; } /*}}}*/ Set_Int_Type; static Set_Int_Type Int_Things_To_Set [] = /*{{{*/ { {"new_subject_breaks_threads", &Slrn_New_Subject_Breaks_Threads}, {"scroll_by_page", &Slrn_Scroll_By_Page}, {"use_color", &SLtt_Use_Ansi_Colors}, {"ignore_signature", &Slrn_Sig_Is_End_Of_Article}, {"reject_long_lines", &Slrn_Reject_Long_Lines}, #if SLRN_HAS_NNTP_SUPPORT {"query_reconnect", &Slrn_Query_Reconnect}, #else {"query_reconnect", NULL}, #endif #if SLRN_HAS_SORT_BY_SCORE {"display_score", &Slrn_Display_Score}, #else {"display_score", NULL}, #endif {"use_xgtitle", &Slrn_Use_Xgtitle}, {"show_article", &Slrn_Startup_With_Article}, {"author_display", &Slrn_Show_Author}, {"display_author_realname", &Slrn_Show_Author_Realname}, {"show_descriptions", &Slrn_Group_Display_Descriptions}, {"no_backups", &Slrn_No_Backups}, {"beep", &SLtt_Ignore_Beep}, {"unsubscribe_new_groups", &Slrn_Unsubscribe_New_Groups}, {"show_thread_subject", &Slrn_Show_Thread_Subject}, {"mouse", &Slrn_Use_Mouse}, {"query_next_group", &Slrn_Query_Next_Group}, {"query_next_article", &Slrn_Query_Next_Article}, {"confirm_actions", &Slrn_User_Wants_Confirmation}, {"cc_followup", &Slrn_Auto_CC_To_Poster}, {"use_tmpdir", &Slrn_Use_Tmpdir}, {"sorting_method", &Slrn_Sorting_Mode}, {"uncollapse_threads", &Slrn_Threads_Visible}, {"read_active", &Slrn_List_Active_File}, {"use_metamail", &Slrn_Use_Meta_Mail}, {"group_dsc_start_column", &Slrn_Group_Description_Column}, {"lines_per_update", &Slrn_Reads_Per_Update}, {"min_high_score", &Slrn_High_Score_Min}, {"max_low_score", &Slrn_Low_Score_Max}, {"kill_score", &Slrn_Kill_Score_Max}, #if !defined(__os2__) && !defined(__NT__) {"use_blink", &SLtt_Blink_Mode}, #endif {"wrap_flags", &Slrn_Wrap_Mode}, {"write_newsrc_flags", &Slrn_Write_Newsrc_Flags}, {"query_read_group_cutoff", &Slrn_Query_Group_Cutoff}, {"prompt_next_group", &Slrn_Prompt_Next_Group}, {"use_header_numbers", &Slrn_Use_Header_Numbers}, #if SLRN_HAS_SPOILERS {"spoiler_char", &Slrn_Spoiler_Char}, {"spoiler_display_mode", &Slrn_Spoiler_Display_Mode}, #else {"spoiler_start_new_page", NULL}, {"spoiler_char", NULL}, #endif #if SLRN_HAS_MIME {"use_mime", &Slrn_Use_Mime}, #else {"use_mime", NULL}, #endif #if SLRN_HAS_GROUPLENS {"use_grouplens", &Slrn_Use_Group_Lens}, {"grouplens_port", &Slrn_GroupLens_Port}, #else {"use_grouplens", NULL}, #endif #if 0 #if SLRN_HAS_INEWS_SUPPORT {"use_inews", &Slrn_Use_Inews}, #else {"use_inews", NULL}, #endif #endif #if SLRN_HAS_PULL_SUPPORT {"use_slrnpull", &Slrn_Use_Pull_Post}, #else {"use_slrnpull", NULL}, #endif #if SLRN_HAS_TILDE_FEATURE {"use_tilde", &Slrn_Use_Tildes}, #else {"use_tilde", NULL}, #endif #if SLRN_HAS_SPOOL_SUPPORT {"spool_check_up_on_nov", &Slrn_Spool_Check_Up_On_Nov}, #else {"spool_check_up_on_nov", NULL}, #endif {NULL, NULL} }; /*}}}*/ typedef struct /*{{{*/ { char *what; char **svaluep; } /*}}}*/ Set_String_Type; static Set_String_Type String_Things_To_Set [] = /*{{{*/ { {"art_help_line", &Slrn_Art_Help_Line}, {"header_help_line", &Slrn_Header_Help_Line}, {"group_help_line", &Slrn_Group_Help_Line}, {"quote_string", &Slrn_Quote_String}, {"realname", &Slrn_User_Info.realname}, {"username", &Slrn_User_Info.username}, {"replyto", &Slrn_User_Info.replyto}, {"organization", &Slrn_User_Info.org}, {"followup", &Slrn_User_Info.followup_string}, /* obsolete */ {"followup_string", &Slrn_User_Info.followup_string}, {"reply_string", &Slrn_User_Info.reply_string}, {"cc_followup_string", &Slrn_Courtesy_CC_Message}, {"editor_command", &Slrn_Editor}, {"post_editor_command", &Slrn_Editor_Post}, {"score_editor_command", &Slrn_Editor_Score}, {"mail_editor_command", &Slrn_Editor_Mail}, {"non_Xbrowser", &Slrn_NonX_Browser}, {"Xbrowser", &Slrn_X_Browser}, {"save_posts", &Slrn_Save_Posts_File}, {"save_replies", &Slrn_Save_Replies_File}, {"save_directory", &Slrn_Save_Directory}, {"postpone_directory", &Slrn_Postpone_Dir}, {"signature", &Slrn_User_Info.signature}, {"custom_headers", &Slrn_Post_Custom_Headers}, {"followup_custom_headers", &Slrn_Followup_Custom_Headers}, {"reply_custom_headers", &Slrn_Reply_Custom_Headers}, #if SLRN_HAS_GROUPLENS {"grouplens_pseudoname", &Slrn_GroupLens_Pseudoname}, {"grouplens_host", &Slrn_GroupLens_Host}, #else {"grouplens_pseudoname", NULL}, {"grouplens_host", NULL}, #endif {"decode_directory", #if SLRN_HAS_DECODE &Slrn_Decode_Directory #else NULL #endif }, {"inews_program", #if SLRN_HAS_INEWS_SUPPORT && SLRN_HAS_USER_INEWS &Slrn_Inews_Pgm #else NULL #endif }, #if SLRN_HAS_MIME {"mime_charset", &Slrn_Mime_Display_Charset}, {"metamail_command", &Slrn_MetaMail_Cmd}, #else {"mime_charset", NULL}, {"metamail_command", NULL}, #endif #if SLRN_HAS_CHARACTER_MAP {"charset", &Slrn_Charset}, #else {"charset", NULL}, #endif #ifndef VMS {"sendmail_command", &Slrn_SendMail_Command}, #endif {"spool_inn_root", #if SLRN_HAS_SPOOL_SUPPORT &Slrn_Inn_Root #else NULL #endif }, {"spool_root", #if SLRN_HAS_SPOOL_SUPPORT &Slrn_Spool_Root #else NULL #endif }, {"spool_nov_root", #if SLRN_HAS_SPOOL_SUPPORT &Slrn_Nov_Root #else NULL #endif }, {"spool_nov_file", #if SLRN_HAS_SPOOL_SUPPORT &Slrn_Nov_File #else NULL #endif }, {"spool_active_file", #if SLRN_HAS_SPOOL_SUPPORT &Slrn_Active_File #else NULL #endif }, {"spool_activetimes_file", #if SLRN_HAS_SPOOL_SUPPORT &Slrn_ActiveTimes_File #else NULL #endif }, {"spool_newsgroups_file", #if SLRN_HAS_SPOOL_SUPPORT &Slrn_Newsgroups_File #else NULL #endif }, {"macro_directory", #if SLRN_HAS_SLANG &Slrn_Macro_Dir #else NULL #endif }, {"server_object", &Server_Object}, {"post_object", &Post_Object}, {NULL, NULL} }; /*}}}*/ int slrn_set_string_variable (char *name, char *value) /*{{{*/ { Set_String_Type *sp = String_Things_To_Set; while (sp->what != NULL) { if (!strcmp (sp->what, name)) { char *ss; if (sp->svaluep == NULL) return 0; ss = *sp->svaluep; slrn_free (ss); if (NULL == (ss = SLmake_string (value))) exit_malloc_error (); *sp->svaluep = ss; return 0; } sp++; } return -1; } /*}}}*/ int slrn_set_integer_variable (char *name, int value) /*{{{*/ { Set_Int_Type *ip = Int_Things_To_Set; while (ip->what != NULL) { if (!strcmp (ip->what, name)) { if (ip->valuep == NULL) return 0; *ip->valuep = value; return 0; } ip++; } return -1; } /*}}}*/ int slrn_get_variable_value (char *name, int *type, char ***sval, int **ival) /*{{{*/ { Set_String_Type *sp; Set_Int_Type *ip; sp = String_Things_To_Set; while (sp->what != NULL) { if (!strcmp (sp->what, name)) { *sval = sp->svaluep; *type = STRING_TYPE; return 0; } sp++; } ip = Int_Things_To_Set; while (ip->what != NULL) { if (!strcmp (ip->what, name)) { *ival = ip->valuep; *type = INT_TYPE; return 0; } ip++; } return -1; } /*}}}*/ static int set_variable_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { int ret; char *what = table->string_args[1]; int ivalue = table->int_args[2]; char *svalue = table->string_args[2]; int type = table->arg_type[2]; (void) argc; if (type == STRING_TYPE) ret = slrn_set_string_variable (what, svalue); else if (type == INT_TYPE) ret = slrn_set_integer_variable (what, ivalue); else ret = -1; if (ret != 0) exit_unknown_object (); return 0; } /*}}}*/ /*}}}*/ /*{{{ Setting Color/Mono Attributes */ typedef struct /*{{{*/ { char *name; int value; char *fg, *bg; SLtt_Char_Type mono; } /*}}}*/ Color_Handle_Type; /* default colors -- suitable for a color xterm */ static Color_Handle_Type Color_Handles[] = /*{{{*/ { {"normal", 0, "black", "white", 0}, {"status", STATUS_COLOR, "yellow", "blue", SLTT_REV_MASK}, {"menu", MENU_COLOR, "yellow", "blue", SLTT_REV_MASK}, {"menu_press", MENU_PRESS_COLOR,"blue", "yellow", 0}, {"headers", HEADER_COLOR, "brightcyan", "white", 0}, {"group", GROUP_COLOR, "blue", "white", 0}, {"subject", SUBJECT_COLOR, "black", "white", 0}, {"author", AUTHOR_COLOR, "magenta", "white", 0}, {"error", ERROR_COLOR, "red", "white", SLTT_BLINK_MASK}, {"cursor", CURSOR_COLOR, "brightgreen", "white", SLTT_REV_MASK}, {"article", ARTICLE_COLOR, "blue", "white", 0}, {"tree", TREE_COLOR, "red", "white", 0}, {"quotes", QUOTE_COLOR, "red", "white", 0}, {"signature", SIGNATURE_COLOR,"red", "white", 0}, {"thread_number", THREAD_NUM_COLOR,"blue", "white", SLTT_BOLD_MASK}, {"header_number", HEADER_NUMBER_COLOR,"green", "white", 0}, {"high_score", HIGH_SCORE_COLOR,"red", "white", SLTT_BOLD_MASK}, {"description", GROUP_DESCR_COLOR,"magenta", "white", 0}, {"grouplens_display",GROUPLENS_DISPLAY_COLOR,"blue","white", 0}, {"tilde", SLRN_TILDE_COLOR,"green", "white", SLTT_BOLD_MASK}, {"header_name",SLRN_HEADER_KEYWORD_COLOR,"green", "white", SLTT_BOLD_MASK}, {"response_char",RESPONSE_CHAR_COLOR,"green", "white", SLTT_BOLD_MASK}, {"box", BOX_COLOR,"black", "white", 0}, {"frame", FRAME_COLOR,"yellow", "blue", SLTT_REV_MASK}, {"selection", SELECT_COLOR,"yellow", "blue", SLTT_BOLD_MASK}, {NULL, -1, NULL, NULL, 0} }; /*}}}*/ int slrn_set_object_color (char *name, char *fg, char *bg) { Color_Handle_Type *ct = Color_Handles; while (ct->name != NULL) { if (!strcmp (ct->name, name)) { SLtt_set_color (ct->value, name, fg, bg); return 0; } ct++; } slrn_error ("%s is not a color object", name); return -1; } static int color_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { char *what = table->string_args[1]; char *fg = table->string_args[2]; char *bg = table->string_args[3]; (void) argc; if (-1 == slrn_set_object_color (what, fg, bg)) exit_unknown_object (); return 0; } /*}}}*/ static int mono_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { char *what = table->string_args[1]; char *attr; int i; Color_Handle_Type *ct = Color_Handles; while (ct->name != NULL) { if (!strcmp (ct->name, what)) { SLtt_Char_Type mono_attr = 0; for (i = 2; i < argc; i++) { attr = table->string_args[i]; if (!strcmp (attr, "bold")) mono_attr |= SLTT_BOLD_MASK; else if (!strcmp (attr, "blink")) mono_attr |= SLTT_BLINK_MASK; else if (!strcmp (attr, "underline")) mono_attr |= SLTT_ULINE_MASK; else if (!strcmp (attr, "reverse")) mono_attr |= SLTT_REV_MASK; else if (!strcmp (attr, "none")) mono_attr = 0; else exit_unknown_object (); } SLtt_set_mono (ct->value, NULL, mono_attr); return 0; } ct++; } exit_unknown_object (); return 0; } /*}}}*/ /*}}}*/ /*{{{ User Info Data (Hostname, etc) */ /*----------------------------------------------------------------------*\ * static int user_data_fun (); * * convenient mechanism to set Slrn_User_Info fields without adding * extra environment variables * * recognized fields * * replyto - alternative name for replies * organization - use double quotes if there are spaces! * signature - an alternate to ~/.signature (for news posting) * hostname - full name of the current host \*----------------------------------------------------------------------*/ typedef struct /*{{{*/ { char *name; char **addr; unsigned int size; } /*}}}*/ User_Info_Variable_Type; static User_Info_Variable_Type User_Info_Variables[] = /*{{{*/ { {"hostname", (char **)Slrn_User_Info.host, MAX_HOST_NAME_LEN}, {"scorefile", &Slrn_Score_File, 0}, #define USER_INFO_OBSOLETE_STARTS_HERE 2 /* The following are obsolete and will not be supported in the future. */ {"username", &Slrn_User_Info.username, 0}, {"realname", &Slrn_User_Info.realname, 0}, {"replyto", &Slrn_User_Info.replyto, 0}, {"organization", &Slrn_User_Info.org, 0}, {"followup", &Slrn_User_Info.followup_string, 0}, {"signature", &Slrn_User_Info.signature, 0}, {"cc_followup_string", &Slrn_Courtesy_CC_Message, 0}, #if SLRN_HAS_DECODE {"decode_directory", &Slrn_Decode_Directory, 0}, #endif {"editor_command", &Slrn_Editor, 0}, {"quote_string", NULL, 0}, {NULL, NULL, 0} }; /*}}}*/ static int user_data_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { char *what = table->string_args[0]; char *field = table->string_args[1]; User_Info_Variable_Type *u = User_Info_Variables; char **ptr, *contents; unsigned int n; (void) argc; while (u->name != NULL) { if (!strcmp (u->name, what)) { n = strlen (field); if (u->size) { contents = (char *) u->addr; strncpy (contents, field, u->size); contents [u->size - 1] = 0; } else if (NULL != (ptr = u->addr)) { contents = safe_malloc (n + 1); strcpy (contents, field); slrn_free (*ptr); *ptr = contents; } if (u >= User_Info_Variables + USER_INFO_OBSOLETE_STARTS_HERE) issue_obsolete_message (); return 0; } u++; } exit_unknown_object (); return -1; } /*}}}*/ /*}}}*/ /*{{{ Server Newsrc Mapping Functions */ typedef struct Server_List_Type /*{{{*/ { struct Server_List_Type *next; char *file; char *host; char *username; char *password; } /*}}}*/ Server_List_Type; static Server_List_Type *Server_List; static Server_List_Type *find_server (char *host) /*{{{*/ { Server_List_Type *s = Server_List; while (s != NULL) { if (0 == slrn_case_strcmp ((unsigned char *)host, (unsigned char *) s->host)) break; s = s->next; } return s; } /*}}}*/ static int add_to_server_list (char *host, char *file, char *username, char *password) /*{{{*/ { Server_List_Type *s; if (NULL == (s = find_server (host))) { s = (Server_List_Type *) safe_malloc (sizeof (Server_List_Type)); memset ((char *) s, 0, sizeof (Server_List_Type)); s->next = Server_List; Server_List = s; s->host = slrn_safe_strmalloc (host); } if (file != NULL) { slrn_free (s->file); s->file = slrn_safe_strmalloc (file); } if (username != NULL) { slrn_free (s->username); s->username = slrn_safe_strmalloc (username); } if (password != NULL) { slrn_free (s->password); s->password = slrn_safe_strmalloc (password); } return 0; } /*}}}*/ static int server_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { char *the_file = table->string_args[2], *the_host = table->string_args[1]; (void) argc; return add_to_server_list (the_host, the_file, NULL, NULL); } /*}}}*/ char *slrn_map_file_to_host (char *host) /*{{{*/ { Server_List_Type *s; if (NULL == (s = find_server (host))) return NULL; return s->file; } /*}}}*/ /*}}}*/ /*{{{ Server Authorization Information */ /*----------------------------------------------------------------------*\ * static int nnrp_fun (); * * convenient mechanism to set nnrp Slrn_User_Info fields without adding * extra environment variables * * recognized fields * * nnrpaccess - used to log in to a server using authinfo * it has the following format. * "host username password" \*----------------------------------------------------------------------*/ static int nnrp_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { #if SLRN_HAS_NNTP_SUPPORT char *server = table->string_args[1]; char *name = table->string_args[2]; char *pass = table->string_args[3]; (void) argc; return add_to_server_list (server, NULL, name, pass); #else (void) argc; (void) table; return 0; #endif } /*}}}*/ int slrn_get_authorization (char *host, char **name, char **pass) /*{{{*/ { Server_List_Type *s; char buf[256]; *name = NULL; *pass = NULL; s = find_server (host); if (s == NULL) return 0; if ((s->username == NULL) || (s->password == NULL)) return 0; if (*s->username == 0) { *buf = 0; if (-1 == slrn_read_input ("Username", NULL, buf, 1, 0)) return -1; SLFREE (s->username); s->username = slrn_safe_strmalloc (buf); } if (*s->password == 0) { *buf = 0; if (-1 == slrn_read_input_no_echo ("Password", NULL, buf, 1, 0)) return -1; SLFREE (s->password); s->password = slrn_safe_strmalloc (buf); } *name = s->username; *pass = s->password; return 0; } /*}}}*/ /*}}}*/ static void slrn_init_modes (void) /*{{{*/ { slrn_init_group_mode (); slrn_init_article_mode (); } /*}}}*/ void slrn_startup_initialize (void) /*{{{*/ { Color_Handle_Type *h; slrn_init_modes (); SLang_init_case_tables (); Slrn_Ignore_Quote_Regexp[0] = compile_quote_regexp ("^ ?[:>]"); h = Color_Handles; while (h->name != NULL) { SLtt_set_color (h->value, NULL, h->fg, h->bg); SLtt_set_mono (h->value, NULL, h->mono); h++; } #if !defined(__os2__) && !defined(__NT__) /* We are not using the blink characters (unless in mono) */ SLtt_Blink_Mode = 0; #endif } /*}}}*/ int slrn_read_startup_file (char *name) /*{{{*/ { FILE *fp; char file [SLRN_MAX_PATH_LEN]; char line [512]; SLPreprocess_Type pt; int save_this_line_num; char *save_this_file; char *save_this_line; if (-1 == slrn_init_readline ()) { slrn_exit_error ("Unable to initialize S-Lang readline library."); } if (-1 == SLprep_open_prep (&pt)) { slrn_exit_error ("Error initializing S-Lang preprocessor."); } fp = slrn_open_home_file (name, "r", file, 0); if (fp == NULL) return -1; slrn_message ("Reading startup file %s.", file); save_this_file = This_File; save_this_line = This_Line; save_this_line_num = This_Line_Num; This_File = file; This_Line = line; This_Line_Num = 0; Slrn_Cmd_Table.table = Slrn_Startup_File_Cmds; while (NULL != fgets (line, sizeof(line) - 1, fp)) { This_Line_Num++; if (SLprep_line_ok (line, &pt)) (void) SLcmd_execute_string (line, &Slrn_Cmd_Table); if (SLang_Error) exit_unknown_object (); } slrn_fclose (fp); SLprep_close_prep (&pt); if ((Server_Object != NULL) && (-1 == (Slrn_Default_Server_Obj = slrn_map_name_to_object_id (0, Server_Object)))) slrn_exit_error ("Server object '%s' is not supported.", Server_Object); if ((Post_Object != NULL) && (-1 == (Slrn_Default_Post_Obj = slrn_map_name_to_object_id (1, Post_Object)))) slrn_exit_error ("Post object '%s' is not supported.", Post_Object); This_File = save_this_file; This_Line = save_this_line; This_Line_Num = save_this_line_num; return 0; } /*}}}*/ static int include_file_fun (int argc, SLcmd_Cmd_Table_Type *table) { char *file; (void) argc; file = table->string_args [1]; if (-1 == slrn_read_startup_file (file)) slrn_exit_error ("%s: line %d:\n%sFile not opened: %s", This_File, This_Line_Num, This_Line, file); return 0; } static int interpret_fun (int argc, SLcmd_Cmd_Table_Type *table) /*{{{*/ { #if SLRN_HAS_SLANG char *file = table->string_args [1]; (void) argc; if (Slrn_Use_Slang == 0) return 0; return slrn_eval_slang_file (file); #else (void) argc; return 0; #endif } /*}}}*/