From: Kern Sibbald Date: Sat, 6 Dec 2003 16:34:21 +0000 (+0000) Subject: add conio.c + fix bsendmsg seg fault some pm_strcpy() cleanups X-Git-Tag: Release-7.0.0~9901 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=2833b40d4c4d54d94d6bfd179112d418288e8b84;p=bacula%2Fbacula add conio.c + fix bsendmsg seg fault some pm_strcpy() cleanups git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@820 91ce42f0-d328-0410-95d8-f526ca767f89 --- diff --git a/bacula/kernstodo b/bacula/kernstodo index a568452632..6b11e17e0a 100644 --- a/bacula/kernstodo +++ b/bacula/kernstodo @@ -60,6 +60,12 @@ For 1.33 Testing/Documentation: - Document lsmark command in tree. For 1.33 +- Fix fast block rejection (stored/read_record.c:118). It passes a null + pointer (rec) to try_repositioning(). +- See if a restore job can add a file to the tape (prohibit this). +- Look at extracting Win data from BackupRead. +- Having dashes in filenames apparently creates problems for restore + by filename. - Add data compare on write/read in btape "test". - Make sure that 64 bit I/O packets are used on Cygwin. - Implement RestoreJobRetention? Maybe better "JobRetention" in a Job, @@ -73,9 +79,13 @@ For 1.33 resources, like Level? If so, I think I'd make it an optional directive in Job, Client, and Pool, with precedence such that Job overrides Client which in turn overrides Pool. +- Fix Ctl-C crashing the Console (readline?). After 1.33: +- Restore: Enter Filename: 'C:/Documents and Settings/Comercial/My + Documents/MOP/formulário de registro BELAS ARTES.doc' causes Bacula to + crash. - Each DVD-RAM disk would be a volume, just like each tape is a volume. It's a 4.7GB media with random access, but there's nothing about it that I can see that makes it so different than a tape from  bacula's diff --git a/bacula/src/console/Makefile.in b/bacula/src/console/Makefile.in index 93661945dc..d7aefc1756 100644 --- a/bacula/src/console/Makefile.in +++ b/bacula/src/console/Makefile.in @@ -20,8 +20,8 @@ first_rule: all dummy: # -CONSSRCS = console.c console_conf.c authenticate.c -CONSOBJS = console.o console_conf.o authenticate.o +CONSSRCS = console.c console_conf.c authenticate.c conio.c +CONSOBJS = console.o console_conf.o authenticate.o conio.o # these are the objects that are changed by the .configure process EXTRAOBJS = @OBJLIST@ diff --git a/bacula/src/console/conio.c b/bacula/src/console/conio.c new file mode 100755 index 0000000000..f44c72c4f0 --- /dev/null +++ b/bacula/src/console/conio.c @@ -0,0 +1,1013 @@ +/* + Generalized consol input/output handler + Kern Sibbald, December MMIII +*/ + +#define BACULA +#ifdef BACULA +#include "bacula.h" +#else +#include +#include +#include +#include +#include +#endif + +#include +#include +#include "func.h" + +/* Global functions imported */ + + +extern char *getenv(char *); + +static void add_smap(char *str, int func); + +/* From termios library */ +extern char *BC; +extern char *UP; + +/* Global variables */ + +static char *t_up = "\n"; /* scroll up character */ +static char *t_honk = "\007"; /* sound beep */ +static char *t_flag = "+"; /* mark flag sequence */ +static char *t_norm = " "; /* clear mark sequence */ +static char *t_il; /* insert line */ +static char *t_dl; /* delete line */ +static char *t_cs; /* clear screen */ +static char *t_cl; /* clear line */ +static int t_width = 79; /* terminal width */ +static int t_height = 24; /* terminal height */ +static int t_flagl = 1; /* # chars for flag */ +static int linsdel_ok = 0; /* set if term has line insert & delete fncs */ +static short dioflag = 1; /* set if ok to use ibm bios calls */ + +static char *t_cm; /* cursor positioning */ +static char *t_ti; /* init sequence */ +static char *t_te; /* end sequence */ +static char *t_do; /* down one line */ +static char *t_sf; /* scroll screen one line up */ + +/* Keypad and Function Keys */ +static char *kl; /* left key */ +static char *kr; /* right */ +static char *ku; +static char *kd; +static char *kh; /* home */ +static char *kb; /* backspace */ +static char *k0; /* function key 10 */ +static char *k1; /* function key 1 */ +static char *k2; /* function key 2 */ +static char *k3; /* function key 3 */ +static char *k4; /* function key 4 */ +static char *k5; /* function key 5 */ +static char *k6; /* function key 6 */ +static char *k7; /* function key 7 */ +static char *k8; /* function key 8 */ +static char *k9; /* function key 9 */ +static char *kD; /* delete key */ +static char *kI; /* insert */ +static char *kN; /* next page */ +static char *kP; /* previous page */ +static char *kH; /* home */ +static char *kE; /* end */ + +static int use_termcap; +#ifndef EOS +#define EOS '\0' /* end of string terminator */ +#endif + +#define TRUE 1 +#define FALSE 0 +/* + * Stab entry. Input chars (str), the length, and the desired + * func code. + */ +typedef struct s_stab { + struct s_stab *next; + int len; + int func; + char *str; +} stab_t; + +#define MAX_STAB 30 + +static stab_t **stab = NULL; /* array of stabs by length */ +static int num_stab; /* size of stab array */ + +/* Local variables */ + +static struct termios old_term_params; + +/* Maintain lines in a doubly linked circular pool of lines. Each line is + preceded by a header defined by the lstr structure */ + + +struct lstr { /* line pool structure */ + struct lstr *prevl; /* link to previous line */ + struct lstr *nextl; /* link to next line */ + long len; /* length of line+header */ + char used; /* set if line valid */ + char line; /* line is actually varying length */ +}; + +#ifdef unix +#define POOLEN 128000 /* bytes in line pool */ +#else +#define POOLEN 500 /* bytes in line pool */ +#endif +char pool[POOLEN]; /* line pool */ +#define PHDRL ((int)sizeof(struct lstr)) /* length of line header */ + +static struct lstr *lptr; /* current line pointer */ +static struct lstr *slptr; /* store line pointer */ +static int cl, cp; +static char *getnext(), *getprev(); +static int first = 1; +static int mode_insert = 0; +static int mode_wspace = 1; /* words separated by spaces */ + +/* Forward referenced functions */ +static void sigintcatcher(int); + +/* Global variables Exported */ + +static short char_map[600]= { + 0, F_NXTWRD, /* ^A Next Word */ + F_SPLIT, /* ^B Split line */ F_EOI, /* ^C Quit */ + F_DELCHR, /* ^D Delete character */ F_EOF, /* ^E End of file */ + F_INSCHR, /* ^F Insert character */ F_TABBAK, /* ^G Back tab */ + F_CSRLFT, /* ^H Left */ F_TAB, /* ^I Tab */ + F_CSRDWN, /* ^J Down */ F_CSRUP, /* ^K Up */ + F_CSRRGT, /* ^L Right */ F_RETURN, /* ^M Carriage return */ + F_EOL, /* ^N End of line */ F_CONCAT, /* ^O Concatenate lines */ + F_MARK, /* ^P Set marker */ F_TINS, /* ^Q Insert character mode */ + F_PAGUP, /* ^R Page up */ F_CENTER, /* ^S Center text */ + F_PAGDWN, /* ^T Page down */ F_SOL, /* ^U Line start */ + F_DELWRD, /* ^V Delete word */ F_PRVWRD, /* ^W Previous word */ + F_NXTMCH, /* ^X Next match */ F_DELEOL, /* ^Y Delete to end of line */ + F_DELLIN, /* ^Z Delete line */ 0x1B, /* ^[=ESC escape */ + F_TENTRY, /* ^\ Entry mode */ F_PASTECB,/* ^]=paste clipboard */ + F_HOME, /* ^^ Home */ F_ERSLIN, /* ^_ Erase line */ + ' ','!','"','#','$','%','&','\047', + '(',')','*','+','\054','-','.','/', + '0','1','2','3','4','5','6','7', + '8','9',':',';','<','=','>','?', + '@','A','B','C','D','E','F','G', + 'H','I','J','K','L','M','N','O', + 'P','Q','R','S','T','U','V','W', + 'X','Y','Z','[','\\',']','^','_', + '\140','a','b','c','d','e','f','g', + 'h','i','j','k','l','m','n','o', + 'p','q','r','s','t','u','v','w', + 'x','y','z','{','|','}','\176',F_ERSCHR /* erase character */ + + }; + + +#define NVID 0x1E /* normal video -- blue */ +#define RVID 0x4F /* reverse video -- red */ +#define MNVID 0x07 /* normal video (monochrome tube) */ +#define MRVID 0x70 /* reverse video (monochrome tube) */ + + +/* Local variables */ + +#define CR '\r' /* carriage return */ + + +/* Function Prototypes */ + +static int input_char(void); +static int t_gnc(void); +static void insert_space(char *curline, int line_len); +static void forward(int i, char *str, int str_len); +static void backup(int i); +static void delchr(int cnt, char *curline, int line_len); +static int iswordc(char c); +static int next_word(char *ldb_buf); +static int prev_word(char *ldb_buf); +static void prtcur(char *str); +static void poolinit(void); +static char * getnext(void); +static char * getprev(void); +static void putline(char *newl, int newlen); +static void t_honk_horn(void); +static void t_insert_line(void); +static void t_delete_line(void); +static void t_clrline(int pos, int width); +static void t_sendl(char *msg, int len); +static void t_send(char *msg); +static void t_char(char c); + +static void rawmode(void); +static void normode(void); +static int t_getch(); +static void trapctlc(); +static void asclrl(int pos, int width); +static void asinsl(); +static void asdell(); + +int input_line(char *string, int length); + +void con_init() +{ + rawmode(); + trapctlc(); +} + +void con_term() +{ + normode(); +} + +#ifndef BACULA +/* + * Guarantee that the string is properly terminated */ +static char *bstrncpy(char *dest, const char *src, int maxlen) +{ + strncpy(dest, src, maxlen-1); + dest[maxlen-1] = 0; + return dest; +} +#endif + + +/* + * New style string mapping to function code + */ +static int do_smap(int c) +{ + char str[MAX_STAB]; + int len = 0; + stab_t *tstab; + int i, found; + + len = 1; + str[0] = c; + str[1] = 0; + + if (c != 27) { + c = char_map[c]; + } + if (c <= 0) { + return c; + } + for ( ;; ) { + found = 0; + for (i=len-1; inext) { + if (strncmp(str, tstab->str, len) == 0) { + if (len == tstab->len) { + return tstab->func; + } + found = 1; + break; /* found possibility continue searching */ + } + } + } + if (!found) { + return len==1?c:0; + } + /* found partial match, so get next character and retry */ + str[len++] = t_gnc(); + str[len] = 0; + } +} + +#ifdef DEBUG_x +static void dump_stab() +{ + int i, j, c; + stab_t *tstab; + char buf[100]; + + for (i=0; inext) { + for (j=0; jlen; j++) { + c = tstab->str[j]; + if (c < 0x20 || c > 0x7F) { + sprintf(buf, " 0x%x ", c); + t_send(buf); + } else { + buf[0] = c; + buf[1] = 0; + t_sendl(buf, 1); + } + } + sprintf(buf, " func=%d len=%d\n\r", tstab->func, tstab->len); + t_send(buf); + } + } +} +#endif + +/* + * New routine. Add string to string->func mapping table. + */ +static void add_smap(char *str, int func) +{ + stab_t *tstab; + int len; + + if (!str) { + return; + } + len = strlen(str); + if (len == 0) { +/* errmsg("String for func %d is zero length\n", func); */ + return; + } + tstab = (stab_t *)malloc(sizeof(stab_t)); + memset(tstab, 0, sizeof(stab_t)); + tstab->len = len; + tstab->str = (char *)malloc(tstab->len + 1); + bstrncpy(tstab->str, str, tstab->len + 1); + tstab->func = func; + if (tstab->len > num_stab) { + printf("stab string too long %d. Max is %d\n", tstab->len, num_stab); + exit(1); + } + tstab->next = stab[tstab->len-1]; + stab[tstab->len-1] = tstab; +/* printf("Add_smap tstab=%x len=%d func=%d tstab->next=%x\n\r", tstab, len, + func, tstab->next); */ + +} + + +/* Get the next character from the terminal - performs table lookup on + the character to do the desired translation */ +static int +/*FCN*/input_char() +{ + int c; + + if ((c=t_gnc()) <= 599) { /* IBM generates codes up to 260 */ + c = do_smap(c); + } else if (c > 1000) { /* stuffed function */ + c -= 1000; /* convert back to function code */ + } + if (c <= 0) { + t_honk_horn(); + } + /* if we got a screen size escape sequence, read height, width */ + if (c == F_SCRSIZ) { + int y, x; + y = t_gnc() - 0x20; /* y */ + x = t_gnc() - 0x20; /* x */ + c = input_char(); + } + return c; +} + + +/* Get a complete input line */ + +int +/*FCN*/input_line(char *string, int length) +{ + char curline[200]; /* edit buffer */ + int noline; + int c; + + if (first) { + poolinit(); /* build line pool */ + first = 0; + } + noline = 1; /* no line fetched yet */ + for (cl=cp=0; cl cp) + cl = cp; + break; + case F_NXTWRD: + forward(next_word(curline),curline, sizeof(curline)); + break; + case F_PRVWRD: + backup(prev_word(curline)); + break; + case F_DELWRD: + delchr(next_word(curline), curline, sizeof(curline)); /* delete word */ + break; + case F_NXTMCH: /* Ctl-X */ + if (cl==0) { + *string = EOS; /* terminate string */ + return(c); /* give it to him */ + } + /* Note fall through */ + case F_DELLIN: + case F_ERSLIN: + backup(cp); /* backup to beginning of line */ + t_clrline(0,t_width); /* erase line */ + cp = 0; + cl = 0; /* reset cursor counter */ + break; + case F_SOL: + backup(cp); + break; + case F_EOL: + while (cp < cl) { + forward(1,curline, sizeof(curline)); + } + while (cp > cl) { + backup(1); + } + break; + case F_TINS: /* toggle insert mode */ + mode_insert = !mode_insert; /* flip bit */ + break; + default: + if (c > 255) { /* function key hit */ + if (cl==0) { /* if first character then */ + *string = EOS; /* terminate string */ + return c; /* return it */ + } + t_honk_horn(); /* complain */ + } else { + if (mode_insert) { + insert_space(curline, sizeof(curline)); + } + curline[cp++] = c; /* store character in line being built */ + t_char((char)c); /* echo character to terminal */ + if (cp > cl) { + cl = cp; /* keep current length */ + } + } + break; + } /* end switch */ + } +/* If we fall through here rather than goto done, the line is too long + simply return what we have now. */ +done: + curline[cl++] = EOS; /* terminate */ + bstrncpy(string,curline,length); /* return line to caller */ + /* Note, put line zaps curline */ + putline(curline,cl); /* save line for posterity */ + return 0; /* give it to him/her */ +} + +/* Insert a space at the current cursor position */ +static void +/*FCN*/insert_space(char *curline, int curline_len) +{ + int i; + + if (cp > cl || cl+1 > curline_len) return; + /* Note! source and destination overlap */ + memmove(&curline[cp+1],&curline[cp],i=cl-cp); + cl++; + i++; + curline[cp] = ' '; + forward(i,curline, curline_len); + backup(i); +} + + +/* Move cursor forward keeping characters under it */ +static void +/*FCN*/forward(int i,char *str, int str_len) +{ + while (i--) { + if (cp > str_len) { + return; + } + if (cp>=cl) { + t_char(' '); + str[cp+1] = ' '; + } else { + t_char(str[cp]); + } + cp++; + } +} + +/* Backup cursor keeping characters under it */ +static void +/*FCN*/backup(int i) +{ + for ( ;i && cp; i--,cp--) + t_char('\010'); +} + +/* Delete the character under the cursor */ +static void +/*FCN*/delchr(int cnt, char *curline, int line_len) +{ + register int i; + + if (cp > cl) + return; + if ((i=cl-cp-cnt+1) > 0) { + memcpy(&curline[cp],&curline[cp+cnt],i); + } + curline[cl -= cnt] = EOS; + t_clrline(0,t_width); + if (cl > cp) { + forward(i=cl-cp,curline, line_len); + backup(i); + } +} + +/* Determine if character is part of a word */ +static int +/*FCN*/iswordc(char c) +{ + if (mode_wspace) + return !isspace(c); + if (c >= '0' && c <= '9') + return TRUE; + if (c == '$' || c == '%') + return TRUE; + return isalpha(c); +} + +/* Return number of characters to get to next word */ +static int +/*FCN*/next_word(char *ldb_buf) +{ + int ncp; + + if (cp > cl) + return 0; + ncp = cp; + for ( ; ncp cl) /* if past eol start at eol */ + ncp=cl+1; + else + ncp = cp; + /* backup to end of previous word - i.e. skip special chars */ + for (i=ncp-1; i && !iswordc(*(ldb_buf+i)); i--) ; + if (i == 0) { /* at beginning of line? */ + return cp; /* backup to beginning */ + } + /* now move back through word to beginning of word */ + for ( ; i && iswordc(*(ldb_buf+i)); i--) ; + ncp = i+1; /* position to first char of word */ + if (i==0 && iswordc(*ldb_buf)) /* check for beginning of line */ + ncp = 0; + return cp-ncp; /* return count */ +} + +/* Display new current line */ +static void +/*FCN*/prtcur(char *str) +{ + backup(cp); + t_clrline(0,t_width); + cp = cl = strlen(str); + t_sendl(str,cl); +} + + +/* Initialize line pool. Split pool into two pieces. */ +static void +/*FCN*/poolinit() +{ + slptr = lptr = (struct lstr *)pool; + lptr->nextl = lptr; + lptr->prevl = lptr; + lptr->used = 1; + lptr->line = 0; + lptr->len = POOLEN; +} + + +/* Return pointer to next line in the pool and advance current line pointer */ +static char * +/*FCN*/getnext() +{ + do { /* find next used line */ + lptr = lptr->nextl; + } while (!lptr->used); + return (char *)&lptr->line; +} + +/* Return pointer to previous line in the pool */ +static char * +/*FCN*/getprev() +{ + do { /* find previous used line */ + lptr = lptr->prevl; + } while (!lptr->used); + return (char *)&lptr->line; +} + +static void +/*FCN*/putline(char *newl, int newlen) +{ + struct lstr *nptr; /* points to next line */ + char *p; + + lptr = slptr; /* get ptr to last line stored */ + lptr = lptr->nextl; /* advance pointer */ + if ((char *)lptr-pool+newlen+PHDRL > POOLEN) { /* not enough room */ + lptr->used = 0; /* delete line */ + lptr = (struct lstr *)pool; /* start at beginning of buffer */ + } + while (lptr->len < newlen+PHDRL) { /* concatenate buffers */ + nptr = lptr->nextl; /* point to next line */ + lptr->nextl = nptr->nextl; /* unlink it from list */ + nptr->nextl->prevl = lptr; + lptr->len += nptr->len; + } + if (lptr->len > newlen + 2 * PHDRL) { /* split buffer */ + nptr = (struct lstr *)((char *)lptr + newlen + PHDRL); + /* Appropriate byte alignment - normally 2 byte, but on + sparc we need 4 byte alignment, so we always do 4 */ + if (((unsigned)nptr & 3) != 0) { /* test four byte alignment */ + p = (char *)nptr; + nptr = (struct lstr *)((((unsigned) p) & ~3) + 4); + } + nptr->len = lptr->len - ((char *)nptr - (char *)lptr); + lptr->len -= nptr->len; + nptr->nextl = lptr->nextl; /* link in new buffer */ + lptr->nextl->prevl = nptr; + lptr->nextl = nptr; + nptr->prevl = lptr; + nptr->used = 0; + } + memcpy(&lptr->line,newl,newlen); + lptr->used = 1; /* mark line used */ + slptr = lptr; /* save as stored line */ +} + +#ifdef DEBUGOUT +static void +/*FCN*/dump(struct lstr *ptr, char *msg) +{ + printf("%s buf=%x nextl=%x prevl=%x len=%d used=%d\n", + msg,ptr,ptr->nextl,ptr->prevl,ptr->len,ptr->used); + if (ptr->used) + printf("line=%s\n",&ptr->line); +} +#endif /* DEBUGOUT */ + + +/* Honk horn on terminal */ +static void +/*FCN*/t_honk_horn() +{ + t_send(t_honk); +} + +/* Insert line on terminal */ +static void +/*FCN*/t_insert_line() +{ + asinsl(); +} + +/* Delete line from terminal */ +static void +/*FCN*/t_delete_line() +{ + asdell(); +} + +/* clear line from pos to width */ +static void +/*FCN*/t_clrline(int pos, int width) +{ + asclrl(pos, width); /* clear to end of line */ +} + +/* Helper function to add string preceded by + * ESC to smap table */ +static void add_esc_smap(char *str, int func) +{ + char buf[100]; + buf[0] = 0x1B; /* esc */ + bstrncpy(buf+1, str, sizeof(buf)-1); + add_smap(buf, func); +} + +/* Set raw mode on terminal file. Basically, get the terminal into a + mode in which all characters can be read as they are entered. CBREAK + mode is not sufficient. + */ +/*FCN*/static void rawmode(void) +{ + struct termios t; + static char term_buf[2048]; + static char *term_buffer = term_buf; + char *termtype = (char *)getenv("TERM"); + + if (tcgetattr(0, &old_term_params) != 0) { + printf("Cannot tcgetattr()\n"); + exit(1); + } + t = old_term_params; + t.c_cc[VMIN] = 1; /* satisfy read after 1 char */ + t.c_cc[VTIME] = 0; + t.c_iflag &= ~(BRKINT | IGNPAR | PARMRK | INPCK | + ISTRIP | ICRNL | IXON | IXOFF | INLCR | IGNCR); + t.c_iflag |= IGNBRK; + t.c_oflag &= ~(OPOST); /* no output processing */ + t.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL | ICANON | + ISIG | NOFLSH | TOSTOP); + tcflush(0, TCIFLUSH); + if (tcsetattr(0, TCSANOW, &t) == -1) { + printf("Cannot tcsetattr()\n"); + } + + signal(SIGQUIT, SIG_IGN); + signal(SIGHUP, SIG_IGN); + signal(SIGSTOP, SIG_IGN); + signal(SIGINT, sigintcatcher); + signal(SIGWINCH, SIG_IGN); + signal(SIGQUIT, SIG_IGN); + signal(SIGCHLD, SIG_IGN); + signal(SIGTSTP, SIG_IGN); + + if (!termtype) { + printf("Cannot get terminal type.\n"); + exit(1); + } + if (tgetent(term_buffer, termtype) < 0) { + printf("Cannot get terminal termcap entry.\n"); + exit(1); + } + t_width = t_height = -1; + t_width = tgetnum("co") - 1; + t_height = tgetnum("li"); + BC = NULL; + UP = NULL; + t_cm = (char *)tgetstr("cm", &term_buffer); + t_cs = (char *)tgetstr("cl", &term_buffer); /* clear screen */ + t_cl = (char *)tgetstr("ce", &term_buffer); /* clear line */ + t_dl = (char *)tgetstr("dl", &term_buffer); /* delete line */ + t_il = (char *)tgetstr("al", &term_buffer); /* insert line */ + t_honk = (char *)tgetstr("bl", &term_buffer); /* beep */ + t_ti = (char *)tgetstr("ti", &term_buffer); + t_te = (char *)tgetstr("te", &term_buffer); + t_up = (char *)tgetstr("up", &term_buffer); + t_do = (char *)tgetstr("do", &term_buffer); + t_sf = (char *)tgetstr("sf", &term_buffer); + t_flag = (char *)tgetstr("so", &term_buffer); + t_norm = (char *)tgetstr("se", &term_buffer); + + + + dioflag = 1; + use_termcap = 1; + t_flagl = tgetnum("sg"); + if (t_flagl < 0) { + t_flagl = 0; + } + + num_stab = MAX_STAB; /* get default stab size */ + stab = (stab_t **)malloc(sizeof(stab_t *) * num_stab); + memset(stab, 0, sizeof(stab_t *) * num_stab); + + /* Key bindings */ + kl = (char *)tgetstr("kl", &term_buffer); + kr = (char *)tgetstr("kr", &term_buffer); + ku = (char *)tgetstr("ku", &term_buffer); + kd = (char *)tgetstr("kd", &term_buffer); + kh = (char *)tgetstr("kh", &term_buffer); + kb = (char *)tgetstr("kb", &term_buffer); + k0 = (char *)tgetstr("k0", &term_buffer); + k1 = (char *)tgetstr("k1", &term_buffer); + k2 = (char *)tgetstr("k2", &term_buffer); + k3 = (char *)tgetstr("k3", &term_buffer); + k4 = (char *)tgetstr("k4", &term_buffer); + k5 = (char *)tgetstr("k5", &term_buffer); + k6 = (char *)tgetstr("k6", &term_buffer); + k7 = (char *)tgetstr("k7", &term_buffer); + k8 = (char *)tgetstr("k8", &term_buffer); + k9 = (char *)tgetstr("k9", &term_buffer); + kD = (char *)tgetstr("kD", &term_buffer); + kI = (char *)tgetstr("kI", &term_buffer); + kN = (char *)tgetstr("kN", &term_buffer); + kP = (char *)tgetstr("kP", &term_buffer); + kH = (char *)tgetstr("kH", &term_buffer); + kE = (char *)tgetstr("kE", &term_buffer); + + add_smap(kl, F_CSRLFT); + add_smap(kr, F_CSRRGT); + add_smap(ku, F_CSRUP); + add_smap(kd, F_CSRDWN); + add_smap(kI, F_TINS); + add_smap(kN, F_PAGDWN); + add_smap(kP, F_PAGUP); + add_smap(kH, F_HOME); + add_smap(kE, F_EOF); + + + add_esc_smap("[A", F_CSRUP); + add_esc_smap("[B", F_CSRDWN); + add_esc_smap("[C", F_CSRRGT); + add_esc_smap("[D", F_CSRLFT); + add_esc_smap("[1~", F_HOME); + add_esc_smap("[2~", F_TINS); + add_esc_smap("[3~", F_DELCHR); + add_esc_smap("[4~", F_EOF); + +#ifdef needed + for (i=301; i<600; i++) { + char_map[i] = i; /* setup IBM function codes */ + } +#endif +} + + +/* Restore tty mode */ +/*FCN*/static void normode() +{ + tcsetattr(0, TCSANOW, &old_term_params); +} + +/* Get next character from terminal/script file/unget buffer */ +static int +/*FCN*/t_gnc() +{ + int ch; + + while ((ch=t_getch()) == 0) ; /* get next input character */ + return(ch); +} + + +/* Get next character from OS */ +static int t_getch(void) +{ + char c; + + if (read(0, &c, 1) != 1) { + c = 0; + } + return (int)c; +} + +#ifdef xxx + +/* window_size -- Return window height and width to caller. */ +static int window_size(int *height, int *width) /* /window_size/ */ +{ + *width = tgetnum("co") - 1; + *height = tgetnum("li"); + return 1; +} +#endif + +/* Send message to terminal - primitive routine */ +static void +/*FCN*/t_sendl(char *msg,int len) +{ + write(1, msg, len); +} + +static void +/*FCN*/t_send(char *msg) +{ + if (msg == NULL) { + return; + } + t_sendl(msg, strlen(msg)); /* faster than one char at time */ +} + +/* Send single character to terminal - primitive routine - + NOTE! don't convert this routine to use the dioflag routines unless + those routines are made to simulate a backspace. */ +static void +/*FCN*/t_char(char c) +{ + write(1, &c, 1); +} + + +static int brkflg = 0; /* set on user break */ + +/* Routine to return true if user types break */ +/*FCN*/int usrbrk() +{ + return brkflg; +} + +/* Clear break flag */ +void clrbrk() +{ + brkflg = 0; + +} + +/* Interrupt caught here */ +static void sigintcatcher(int sig) +{ + brkflg = 1; + signal(SIGINT, sigintcatcher); +} + + +/* Trap Ctl-C */ +/*FCN*/void trapctlc() +{ + signal(SIGINT, sigintcatcher); +} + + +/* ASCLRL() -- Clear to end of line from current position */ +static void asclrl(int pos, int width) +{ + int i; + + if (t_cl) { + t_send(t_cl); /* use clear to eol function */ + return; + } + if (pos==1 && linsdel_ok) { + t_delete_line(); /* delete line */ + t_insert_line(); /* reinsert it */ + return; + } + for (i=1; i<=width-pos+1; i++) + t_char(' '); /* last resort, blank it out */ + for (i=1; i<=width-pos+1; i++) /* backspace to original position */ + t_char(0x8); + return; + +} + +#ifdef xxx + +/* ASCURS -- Set cursor position */ +static void ascurs(int y, int x) +{ + t_send((char *)tgoto(t_cm, x, y)); +} + + +/* ASCLRS -- Clear whole screen */ +static void asclrs() +{ + ascurs(0,0); + t_send(t_cs); +} + +#endif + + +/* ASINSL -- insert new line after cursor */ +static void asinsl() +{ + t_clrline(0, t_width); + t_send(t_il); /* insert before */ +} + +/* ASDELL -- Delete line at cursor */ +static void asdell() +{ + t_send(t_dl); +} diff --git a/bacula/src/dird/msgchan.c b/bacula/src/dird/msgchan.c index 304cfd5336..1f3d42bb9c 100644 --- a/bacula/src/dird/msgchan.c +++ b/bacula/src/dird/msgchan.c @@ -95,7 +95,6 @@ int start_storage_daemon_job(JCR *jcr) BSOCK *sd; char auth_key[100]; POOLMEM *device_name, *pool_name, *pool_type, *media_type; - int device_name_len, pool_name_len, pool_type_len, media_type_len; storage = jcr->store; sd = jcr->store_bsock; @@ -136,24 +135,18 @@ int start_storage_daemon_job(JCR *jcr) /* * Send use device = xxx media = yyy pool = zzz */ - device_name_len = strlen(storage->dev_name) + 1; - media_type_len = strlen(storage->media_type) + 1; - pool_type_len = strlen(jcr->pool->pool_type) + 1; - pool_name_len = strlen(jcr->pool->hdr.name) + 1; - device_name = get_memory(device_name_len); - pool_name = get_memory(pool_name_len); - pool_type = get_memory(pool_type_len); - media_type = get_memory(media_type_len); - memcpy(device_name, storage->dev_name, device_name_len); - memcpy(media_type, storage->media_type, media_type_len); - memcpy(pool_type, jcr->pool->pool_type, pool_type_len); - memcpy(pool_name, jcr->pool->hdr.name, pool_name_len); + device_name = get_pool_memory(PM_NAME); + pool_name = get_pool_memory(PM_NAME); + pool_type = get_pool_memory(PM_NAME); + media_type = get_pool_memory(PM_NAME); + pm_strcpy(&device_name, storage->dev_name); + pm_strcpy(&media_type, storage->media_type); + pm_strcpy(&pool_type, jcr->pool->pool_type); + pm_strcpy(&pool_name, jcr->pool->hdr.name); bash_spaces(device_name); bash_spaces(media_type); bash_spaces(pool_type); bash_spaces(pool_name); - sd->msg = check_pool_memory_size(sd->msg, sizeof(device_name) + - device_name_len + media_type_len + pool_type_len + pool_name_len); bnet_fsend(sd, use_device, device_name, media_type, pool_name, pool_type); Dmsg1(110, ">stored: %s", sd->msg); status = response(jcr, sd, OK_device, "Use Device", NO_DISPLAY); @@ -163,7 +156,6 @@ int start_storage_daemon_job(JCR *jcr) " Storage daemon didn't accept Device \"%s\" because:\n %s"), device_name, pool_type/* sd->msg */); } - free_memory(device_name); free_memory(media_type); free_memory(pool_name); diff --git a/bacula/src/dird/ua_input.c b/bacula/src/dird/ua_input.c index c0f3ea74ed..3321fddf0c 100644 --- a/bacula/src/dird/ua_input.c +++ b/bacula/src/dird/ua_input.c @@ -55,8 +55,8 @@ int get_cmd(UAContext *ua, char *prompt) if (is_bnet_stop(sock)) { return 0; /* error or terminate */ } - ua->cmd = check_pool_memory_size(ua->cmd, sock->msglen+1); - bstrncpy(ua->cmd, sock->msg, sock->msglen+1); + Dmsg1(000, "sock->msglen=%d\n", sock->msglen); + pm_strcpy(&ua->cmd, sock->msg); strip_trailing_junk(ua->cmd); if (strcmp(ua->cmd, ".messages") == 0) { qmessagescmd(ua, ua->cmd); diff --git a/bacula/src/dird/ua_output.c b/bacula/src/dird/ua_output.c index 31a91f36ac..b2ec0eee23 100644 --- a/bacula/src/dird/ua_output.c +++ b/bacula/src/dird/ua_output.c @@ -651,11 +651,12 @@ again: len = bvsnprintf(msg, maxlen, fmt, arg_ptr); va_end(arg_ptr); if (len < 0 || len >= maxlen) { - msg = realloc_pool_memory(msg, maxlen + 200); + msg = realloc_pool_memory(msg, maxlen + maxlen/2); goto again; } if (bs) { + bs->msg = msg; bs->msglen = len; bnet_send(bs); } else { /* No UA, send to Job */ diff --git a/bacula/src/lib/bnet.c b/bacula/src/lib/bnet.c index be35ef7d5d..13485befa1 100644 --- a/bacula/src/lib/bnet.c +++ b/bacula/src/lib/bnet.c @@ -284,7 +284,7 @@ int bnet_despool(BSOCK *bsock) bsock->msglen = ntohl(pktsiz); if (bsock->msglen > 0) { if (bsock->msglen > (int32_t)sizeof_pool_memory(bsock->msg)) { - bsock->msg = realloc_pool_memory(bsock->msg, bsock->msglen); + bsock->msg = realloc_pool_memory(bsock->msg, bsock->msglen + 1); } nbytes = fread(bsock->msg, 1, bsock->msglen, bsock->spool_fd); if (nbytes != (size_t)bsock->msglen) { @@ -697,7 +697,7 @@ again: bs->msglen = bvsnprintf(mp_chr(bs->msg), maxlen, fmt, arg_ptr); va_end(arg_ptr); if (bs->msglen < 0 || bs->msglen >= maxlen) { - bs->msg = realloc_pool_memory(bs->msg, maxlen + 200); + bs->msg = realloc_pool_memory(bs->msg, maxlen + maxlen / 2); goto again; } return bnet_send(bs); diff --git a/bacula/src/lib/bsys.c b/bacula/src/lib/bsys.c index 8e66a9adf9..b421e2e2e0 100644 --- a/bacula/src/lib/bsys.c +++ b/bacula/src/lib/bsys.c @@ -108,7 +108,7 @@ void *bcalloc (size_t size1, size_t size2) /* * Implement snprintf */ -int bsnprintf(char *str, size_t size, const char *fmt, ...) +int bsnprintf(char *str, int32_t size, const char *fmt, ...) { #ifdef HAVE_VSNPRINTF va_list arg_ptr; @@ -143,7 +143,7 @@ int bsnprintf(char *str, size_t size, const char *fmt, ...) /* * Implement vsnprintf() */ -int bvsnprintf(char *str, size_t size, const char *format, va_list ap) +int bvsnprintf(char *str, int32_t size, const char *format, va_list ap) { #ifdef HAVE_VSNPRINTF int len; diff --git a/bacula/src/lib/jcr.c b/bacula/src/lib/jcr.c index 03c86d08b5..0eb07274d8 100755 --- a/bacula/src/lib/jcr.c +++ b/bacula/src/lib/jcr.c @@ -327,6 +327,9 @@ JCR *get_jcr_by_partial_name(char *Job) JCR *jcr; int len; + if (!Job) { + return NULL; + } P(mutex); len = strlen(Job); for (jcr = jobs; jcr; jcr=jcr->next) { @@ -351,6 +354,9 @@ JCR *get_jcr_by_full_name(char *Job) { JCR *jcr; + if (!Job) { + return NULL; + } P(mutex); for (jcr = jobs; jcr; jcr=jcr->next) { if (strcmp(jcr->Job, Job) == 0) { diff --git a/bacula/src/lib/message.c b/bacula/src/lib/message.c index 6391df5908..ffc431dade 100755 --- a/bacula/src/lib/message.c +++ b/bacula/src/lib/message.c @@ -1025,7 +1025,7 @@ again: len = bvsnprintf(*pool_buf+i, maxlen, fmt, arg_ptr); va_end(arg_ptr); if (len < 0 || len >= maxlen) { - *pool_buf = realloc_pool_memory(*pool_buf, maxlen + i + 200); + *pool_buf = realloc_pool_memory(*pool_buf, maxlen + i + maxlen/2); goto again; } return len; @@ -1046,7 +1046,7 @@ again: len = bvsnprintf(*pool_buf, maxlen, fmt, arg_ptr); va_end(arg_ptr); if (len < 0 || len >= maxlen) { - *pool_buf = realloc_pool_memory(*pool_buf, maxlen + 200); + *pool_buf = realloc_pool_memory(*pool_buf, maxlen + maxlen/2); goto again; } return len; @@ -1072,7 +1072,7 @@ again: len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr); va_end(arg_ptr); if (len < 0 || len >= maxlen) { - pool_buf = realloc_pool_memory(pool_buf, maxlen + i + 200); + pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2); goto again; } diff --git a/bacula/src/lib/protos.h b/bacula/src/lib/protos.h index 24bd211d24..c04472e5b1 100644 --- a/bacula/src/lib/protos.h +++ b/bacula/src/lib/protos.h @@ -47,8 +47,8 @@ void *bmalloc (size_t size); #endif void *brealloc (void *buf, size_t size); void *bcalloc (size_t size1, size_t size2); -int bsnprintf (char *str, size_t size, const char *format, ...); -int bvsnprintf (char *str, size_t size, const char *format, va_list ap); +int bsnprintf (char *str, int32_t size, const char *format, ...); +int bvsnprintf (char *str, int32_t size, const char *format, va_list ap); int pool_sprintf (char *pool_buf, char *fmt, ...); void create_pid_file (char *dir, char *progname, int port); int delete_pid_file (char *dir, char *progname, int port); diff --git a/bacula/src/version.h b/bacula/src/version.h index 0c6a81cfde..4add2c20e9 100644 --- a/bacula/src/version.h +++ b/bacula/src/version.h @@ -2,8 +2,8 @@ #undef VERSION #define VERSION "1.33" #define VSTRING "1" -#define BDATE "28 Nov 2003" -#define LSMDATE "28Nov03" +#define BDATE "06 Dec 2003" +#define LSMDATE "06Dec03" /* Debug flags */ #undef DEBUG