bool Transporter::connect_client(NDB_SOCKET_TYPE sockfd) { if(m_connected) return true; if (sockfd == NDB_INVALID_SOCKET) return false; DBUG_ENTER("Transporter::connect_client"); DBUG_PRINT("info",("port %d isMgmConnection=%d",m_s_port,isMgmConnection)); SocketOutputStream s_output(sockfd); SocketInputStream s_input(sockfd); // send info about own id // send info about own transporter type s_output.println("%d %d", localNodeId, m_type); // get remote id int nodeId, remote_transporter_type= -1; char buf[256]; if (s_input.gets(buf, 256) == 0) { NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } int r= sscanf(buf, "%d %d", &nodeId, &remote_transporter_type); switch (r) { case 2: break; case 1: // we're running version prior to 4.1.9 // ok, but with no checks on transporter configuration compatability break; default: NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } DBUG_PRINT("info", ("nodeId=%d remote_transporter_type=%d", nodeId, remote_transporter_type)); if (remote_transporter_type != -1) { if (remote_transporter_type != m_type) { DBUG_PRINT("error", ("Transporter types mismatch this=%d remote=%d", m_type, remote_transporter_type)); NDB_CLOSE_SOCKET(sockfd); g_eventLogger.error("Incompatible configuration: transporter type " "mismatch with node %d", nodeId); DBUG_RETURN(false); } } else if (m_type == tt_SHM_TRANSPORTER) { g_eventLogger.warning("Unable to verify transporter compatability with node %d", nodeId); } { struct sockaddr_in addr; SOCKET_SIZE_TYPE addrlen= sizeof(addr); getpeername(sockfd, (struct sockaddr*)&addr, &addrlen); m_connect_address= (&addr)->sin_addr; } bool res = connect_client_impl(sockfd); if(res){ m_connected = true; m_errorCount = 0; } DBUG_RETURN(res); }
/* * Name: record_on_off * Purpose: save keystrokes in keystroke buffer * Date: April 1, 1992 * Passed: window: pointer to current window * Notes: -1 in .next field indicates the end of a recording * -1 in .key field indicates the initial, unassigned macro key * STROKE_LIMIT+1 in .next field indicates an unused space. */ int record_on_off( WINDOW *window ) { register int next; int prev; int line; int key; int func; char line_buff[(MAX_COLS+2)*2]; /* buffer for char and attribute */ mode.record = !mode.record; if (mode.record == TRUE) { line = window->bottom_line; show_avail_strokes( ); save_screen_line( 0, line, line_buff ); /* * press key that will play back recording */ set_prompt( main11, line ); /* * get the candidate macro key and look up the function assigned to it. */ key = getkey( ); func = getfunc( key ); /* * the key must be an unused, recognized function key or a function * key assigned to a previously defined macro. we also need room * in the macro structure. */ if (key <= 256 || (func != 0 && func != PlayBack)) { /* * cannot assign a recording to this key */ error( WARNING, line, main12 ); mode.record = FALSE; } else if (g_status.stroke_count == 0) { /* * no more room in recording buffer */ error( WARNING, line, main13 ); mode.record = FALSE; } else { /* * everything is everything so far, just check for a prev macro */ prev = OK; if (func == PlayBack) { /* * overwrite recording (y/n)? */ set_prompt( main14, line ); if (get_yn( ) == A_NO) { prev = ERROR; mode.record = FALSE; } } if (prev == OK) { g_status.recording_key = key; next = macro.first_stroke[key-256]; /* * if key has already been assigned to a macro, clear macro def. */ if (next != STROKE_LIMIT+1) { do { prev = next; next = macro.strokes[next].next; macro.strokes[prev].key = MAX_KEYS+1; macro.strokes[prev].next = STROKE_LIMIT+1; ++g_status.stroke_count; } while (next != -1); show_avail_strokes( ); } /* * find the first open space and initialize */ for (next=0; macro.strokes[next].next != STROKE_LIMIT+1;) next++; macro.first_stroke[key-256] = next; macro.strokes[next].key = -1; macro.strokes[next].next = -1; key_func.key[key-256] = PlayBack; /* * recording */ s_output( main15, g_display.mode_line, 22, g_display.mode_color | 0x80 ); } } restore_screen_line( 0, line, line_buff ); } /* * the flashing "Recording" and the stroke count write over the modes. * when we get thru defining a macro, redisplay the modes. */ if (mode.record == FALSE) { memset( line_buff, ' ', 36 ); line_buff[36] = '\0'; s_output( line_buff, g_display.mode_line, 22, g_display.mode_color ); show_tab_modes( ); show_indent_mode( ); show_sync_mode( ); show_search_case( ); show_wordwrap_mode( ); /* * let's look at the macro. if the first .key of the macro is * still -1, which is the initial unassigned key in a macro, reset * the macro so other keys may be assigned to this node. */ key = g_status.recording_key; if (key != 0) { next = macro.first_stroke[key-256]; if (macro.strokes[next].key == -1) { macro.strokes[next].key = MAX_KEYS+1; macro.strokes[next].next = STROKE_LIMIT+1; macro.first_stroke[key-256] = STROKE_LIMIT+1; if (getfunc( key ) == PlayBack) key_func.key[key-256] = 0; } } g_status.recording_key = 0; } return( OK ); }
bool TransporterRegistry::connect_server(NDB_SOCKET_TYPE sockfd) { DBUG_ENTER("TransporterRegistry::connect_server"); // read node id from client // read transporter type int nodeId, remote_transporter_type= -1; SocketInputStream s_input(sockfd); char buf[256]; if (s_input.gets(buf, 256) == 0) { DBUG_PRINT("error", ("Could not get node id from client")); DBUG_RETURN(false); } int r= sscanf(buf, "%d %d", &nodeId, &remote_transporter_type); switch (r) { case 2: break; case 1: // we're running version prior to 4.1.9 // ok, but with no checks on transporter configuration compatability break; default: DBUG_PRINT("error", ("Error in node id from client")); DBUG_RETURN(false); } DBUG_PRINT("info", ("nodeId=%d remote_transporter_type=%d", nodeId,remote_transporter_type)); //check that nodeid is valid and that there is an allocated transporter if ( nodeId < 0 || nodeId >= (int)maxTransporters) { DBUG_PRINT("error", ("Node id out of range from client")); DBUG_RETURN(false); } if (theTransporters[nodeId] == 0) { DBUG_PRINT("error", ("No transporter for this node id from client")); DBUG_RETURN(false); } //check that the transporter should be connected if (performStates[nodeId] != TransporterRegistry::CONNECTING) { DBUG_PRINT("error", ("Transporter in wrong state for this node id from client")); DBUG_RETURN(false); } Transporter *t= theTransporters[nodeId]; // send info about own id (just as response to acknowledge connection) // send info on own transporter type SocketOutputStream s_output(sockfd); s_output.println("%d %d", t->getLocalNodeId(), t->m_type); if (remote_transporter_type != -1) { if (remote_transporter_type != t->m_type) { DBUG_PRINT("error", ("Transporter types mismatch this=%d remote=%d", t->m_type, remote_transporter_type)); g_eventLogger.error("Incompatible configuration: Transporter type " "mismatch with node %d", nodeId); // wait for socket close for 1 second to let message arrive at client { fd_set a_set; FD_ZERO(&a_set); FD_SET(sockfd, &a_set); struct timeval timeout; timeout.tv_sec = 1; timeout.tv_usec = 0; select(sockfd+1, &a_set, 0, 0, &timeout); } DBUG_RETURN(false); } } else if (t->m_type == tt_SHM_TRANSPORTER) { g_eventLogger.warning("Unable to verify transporter compatability with node %d", nodeId); } // setup transporter (transporter responsible for closing sockfd) t->connect_server(sockfd); DBUG_RETURN(true); }
int main(int argc, const char **argv) { struct commandline cmd; memset(&cmd, 0, sizeof (struct commandline)); clear_args(); if (!parseargs(argc, argv, &cmd)) usage(); /* * Only the client and server side stubs are likely to be customized, * so in that case only, check if the outfile exists, and if so, * print an error message and exit. */ if (cmd.Ssflag || cmd.Scflag || cmd.makefileflag) checkfiles(cmd.infile, cmd.outfile); else checkfiles(cmd.infile, NULL); if (cmd.cflag) { c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile); } else if (cmd.hflag) { h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile, cmd.hflag); } else if (cmd.lflag) { l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile); } else if (cmd.sflag || cmd.mflag || (cmd.nflag)) { s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND, cmd.outfile, cmd.mflag, cmd.nflag); } else if (cmd.tflag) { t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile); } else if (cmd.Ssflag) { svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile); } else if (cmd.Scflag) { clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile); } else if (cmd.makefileflag) { mkfile_output(&cmd); } else { /* the rescans are required, since cpp may effect input */ c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c"); reinitialize(); h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h", cmd.hflag); reinitialize(); l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c"); reinitialize(); if (inetdflag || !tirpcflag) s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND, "_svc.c", cmd.mflag, cmd.nflag); else s_output(allnc, allnv, cmd.infile, "-DRPC_SVC", EXTEND, "_svc.c", cmd.mflag, cmd.nflag); if (tblflag) { reinitialize(); t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i"); } if (allfiles) { reinitialize(); svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c"); reinitialize(); clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c"); } if (allfiles || (cmd.makefileflag == 1)){ reinitialize(); mkfile_output(&cmd); } } exit(nonfatalerrors); /* NOTREACHED */ }
bool Transporter::connect_client(NDB_SOCKET_TYPE sockfd) { DBUG_ENTER("Transporter::connect_client(sockfd)"); if(m_connected) { DBUG_PRINT("error", ("Already connected")); DBUG_RETURN(true); } if (!my_socket_valid(sockfd)) { DBUG_PRINT("error", ("Socket " MY_SOCKET_FORMAT " is not valid", MY_SOCKET_FORMAT_VALUE(sockfd))); DBUG_RETURN(false); } DBUG_PRINT("info",("server port: %d, isMgmConnection: %d", m_s_port, isMgmConnection)); // Send "hello" DBUG_PRINT("info", ("Sending own nodeid: %d and transporter type: %d", localNodeId, m_type)); SocketOutputStream s_output(sockfd); if (s_output.println("%d %d", localNodeId, m_type) < 0) { DBUG_PRINT("error", ("Send of 'hello' failed")); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Read reply DBUG_PRINT("info", ("Reading reply")); char buf[256]; SocketInputStream s_input(sockfd); if (s_input.gets(buf, 256) == 0) { DBUG_PRINT("error", ("Failed to read reply")); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Parse reply int nodeId, remote_transporter_type= -1; int r= sscanf(buf, "%d %d", &nodeId, &remote_transporter_type); switch (r) { case 2: break; case 1: // we're running version prior to 4.1.9 // ok, but with no checks on transporter configuration compatability break; default: DBUG_PRINT("error", ("Failed to parse reply")); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } DBUG_PRINT("info", ("nodeId=%d remote_transporter_type=%d", nodeId, remote_transporter_type)); // Check nodeid if (nodeId != remoteNodeId) { g_eventLogger->error("Connected to wrong nodeid: %d, expected: %d", nodeId, remoteNodeId); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Check transporter type if (remote_transporter_type != -1 && remote_transporter_type != m_type) { g_eventLogger->error("Connection to node: %d uses different transporter " "type: %d, expected type: %d", nodeId, remote_transporter_type, m_type); NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Cache the connect address my_socket_connect_address(sockfd, &m_connect_address); if (!connect_client_impl(sockfd)) DBUG_RETURN(false); m_connected = true; DBUG_RETURN(true); }
int main(int argc, char *argv[]) { struct commandline cmd; #ifdef AFS_NT40_ENV /* initialize CPP with the correct pre-processor for Windows */ CPP = getenv("RXGEN_CPPCMD"); if (!CPP) CPP = "cl /EP /C /nologo"; #endif /* AFS_NT40_ENV */ #ifdef AFS_AIX32_ENV /* * The following signal action for AIX is necessary so that in case of a * crash (i.e. core is generated) we can include the user's data section * in the core dump. Unfortunately, by default, only a partial core is * generated which, in many cases, isn't too useful. */ struct sigaction nsa; sigemptyset(&nsa.sa_mask); nsa.sa_handler = SIG_DFL; nsa.sa_flags = SA_FULLDUMP; sigaction(SIGSEGV, &nsa, NULL); #endif reinitialize(); if (!parseargs(argc, argv, &cmd)) { f_print(stderr, "usage: %s infile\n", cmdname); f_print(stderr, " %s [-c | -h | -l | -m | -C | -S | -r | -b | -k | -R | -p | -d | -z | -u] [-Pprefix] [-Idir] [-o outfile] [infile]\n", cmdname); f_print(stderr, " %s [-s udp|tcp]* [-o outfile] [infile]\n", cmdname); exit(1); } OutFileFlag = cmd.outfile; if (OutFileFlag) strcpy(OutFile, cmd.outfile); if (cmd.cflag) { OutFileFlag = NULL; c_output(cmd.infile, "-DRPC_XDR", !EXTEND, cmd.outfile, 0); } else if (cmd.hflag) { h_output(cmd.infile, "-DRPC_HDR", !EXTEND, cmd.outfile, 0); } else if (cmd.lflag) { l_output(cmd.infile, "-DRPC_CLNT", !EXTEND, cmd.outfile); } else if (cmd.sflag || cmd.mflag) { s_output(argc, argv, cmd.infile, "-DRPC_SVC", !EXTEND, cmd.outfile, cmd.mflag); } else if (cmd.Cflag) { OutFileFlag = NULL; C_output(cmd.infile, "-DRPC_CLIENT", !EXTEND, cmd.outfile, 1); } else if (cmd.Sflag) { OutFileFlag = NULL; S_output(cmd.infile, "-DRPC_SERVER", !EXTEND, cmd.outfile, 1); } else { if (OutFileFlag && (strrchr(OutFile, '.') == NULL)) strcat(OutFile, "."); if (cmd.rflag) { C_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_CLIENT", EXTEND, ".cs.c", 1); reinitialize(); S_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_SERVER", EXTEND, ".ss.c", 1); reinitialize(); } else { reinitialize(); c_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_XDR", EXTEND, ".xdr.c", 0); reinitialize(); h_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_HDR", EXTEND, ".h", 0); reinitialize(); C_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_CLIENT", EXTEND, ".cs.c", 1); reinitialize(); S_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_SERVER", EXTEND, ".ss.c", 1); reinitialize(); } } if (fin && pclose_fin) { /* the cpp command we called returned a non-zero exit status */ if (pclose(fin)) { crash(); } } exit(0); }
void GeneralTab::outputChanged(int output) { s_output(output); updateVideoOutput(); }
/* * Name: select_file * Purpose: To let user select a file from dir list * Date: February 13, 1992 * Passed: flist: pointer to list of files * stem: base directory * dir: directory display stuff * Notes: let user move thru the file names with the cursor keys */ int select_file( FTYPE *flist, char *stem, DIRECTORY *dir ) { int ch; /* input character from user */ int func; /* function of character input by user */ int fno; /* index into flist of the file under cursor */ int goodkey; /* is key a recognized function key? */ int r; /* current row of cursor */ int c; /* current column of cursor */ int offset; /* offset into file list */ int stop; /* stop indicator */ int stem_len; /* stem length */ int color; /* color of help screen */ int file_color; /* color of current file */ int change; /* boolean, hilite another file? */ int oldr; /* old row */ int oldc; /* old column */ char asize[20]; /* ascii file size */ char blank[20]; /* blank out file names */ /* * initial everything. */ memset( blank, ' ', 12 ); blank[12] = '\0'; c = r = 1; ch = fno = offset = 0; color = g_display.help_color; file_color = g_display.hilited_file; goodkey = TRUE; stop = FALSE; stem_len = strlen( stem ); s_output( stem, dir->row+1, dir->col+19, color ); s_output( flist[fno].fname, dir->row+1, dir->col+19+stem_len, color ); ltoa( flist[fno].fsize, asize, 10 ); s_output( blank, dir->row+2, dir->col+19, color ); s_output( asize, dir->row+2, dir->col+19, color ); itoa( dir->cnt, asize, 10 ); s_output( blank, dir->row+2, dir->col+57, color ); s_output( asize, dir->row+2, dir->col+57, color ); xygoto( (c-1)*14+dir->col+2, r+dir->row+3 ); hlight_line( (c-1)*14+dir->col+2, r+dir->row+3, 12, file_color ); change = FALSE; while (stop == FALSE) { oldr = r; oldc = c; ch = getkey( ); func = getfunc( ch ); /* * User may have redefined the Enter and ESC keys. Make the Enter key * perform a Rturn in this function. Make the ESC key do an AbortCommand. */ if (ch == RTURN) func = Rturn; else if (ch == ESC) func = AbortCommand; switch (func) { case Rturn : case NextLine : case BegNextLine : stop = TRUE; break; case AbortCommand : stop = TRUE; break; case LineUp : if (r > 1) { change = TRUE; --r; } else { r = dir->lines; change = TRUE; if (offset == 0 || c > 1) { if (c > 1) --c; } else if (dir->vcols > 0 && offset > 0 && c == 1) { /* * recalculate the dir display stuff. */ offset -= dir->lines; recalculate_dir( dir, flist, offset ); } } goodkey = TRUE; break; case LineDown : if (r < dir->prow) { change = TRUE; ++r; } else if (r < dir->lines && c != dir->cols) { change = TRUE; ++r; } else { change = TRUE; r = 1; if (offset == dir->vcols * dir->lines || c < dir->cols) { if (c < dir->cols) ++c; } else if (dir->vcols > 0 && offset < dir->vcols * dir->lines && c == dir->cols) { offset += dir->lines; recalculate_dir( dir, flist, offset ); } } goodkey = TRUE; break; case CharLeft : if (offset == 0 || c > 1) { if (c > 1) { change = TRUE; --c; } } else if (dir->vcols > 0 && offset > 0 && c == 1) { change = TRUE; /* * recalculate the dir display stuff. */ offset -= dir->lines; recalculate_dir( dir, flist, offset ); } goodkey = TRUE; break; case CharRight : if (offset == dir->vcols * dir->lines || c < dir->cols) { if (c < dir->cols) { change = TRUE; ++c; if (c == dir->cols) { if ( r > dir->prow) r = dir->prow; } } } else if (dir->vcols > 0 && offset < dir->vcols * dir->lines && c == dir->cols) { change = TRUE; offset += dir->lines; recalculate_dir( dir, flist, offset ); if (r > dir->prow) r = dir->prow; } goodkey = TRUE; break; case BegOfLine : change = TRUE; c = r = 1; goodkey = TRUE; break; case EndOfLine : change = TRUE; r = dir->prow; c = dir->cols; goodkey = TRUE; break; case ScreenDown : change = TRUE; r = (c == dir->cols) ? r = dir->prow : dir->lines; goodkey = TRUE; break; case ScreenUp : change = TRUE; r = 1; goodkey = TRUE; break; default : break; } if (goodkey) { s_output( blank, dir->row+1, dir->col+19+stem_len, color ); fno = offset + (c-1)*dir->lines + (r-1); s_output( flist[fno].fname, dir->row+1, dir->col+19+stem_len, color ); ltoa( flist[fno].fsize, asize, 10 ); s_output( blank, dir->row+2, dir->col+19, color ); s_output( asize, dir->row+2, dir->col+19, color ); xygoto( (c-1)*14+dir->col+2, r+dir->row+3 ); goodkey = FALSE; if (change) { hlight_line( (oldc-1)*14+dir->col+2, oldr+dir->row+3, 12, color ); hlight_line( (c-1)*14+dir->col+2, r+dir->row+3, 12, file_color ); change = FALSE; } } } dir->select = fno; return( func == AbortCommand ? ERROR : OK ); }
/* * Name: differ * Purpose: diff text pointers * Date: October 31, 1992 * Passed: initial_rcol1: beginning column to begin diff in window1 * initial_rcol2: beginning column to begin diff in window2 * bottom: line to display diagnostics * Notes: a straight diff on text pointers is simple; however, diffing * with leading spaces and tabs is kinda messy. let's do the * messy diff. */ int differ( int initial_rcol1, int initial_rcol2, int bottom ) { int rcol1; /* virtual real column on diff window 1 */ int rcol2; /* virtual real column on diff window 2 */ int r1; /* real real column rcol1 - needed for tabs */ int r2; /* real real column rcol2 - needed for tabs */ char c1; /* character under r1 */ char c2; /* character under r2 */ int leading1; /* adjustment for leading space in window 1 */ int leading2; /* adjustment for leading space in window 2 */ int len1; /* length of diff1 line */ int len2; /* length of diff2 line */ line_list_ptr node1; /* scratch node in window 1 */ line_list_ptr node2; /* scratch node in window 2 */ text_ptr diff1; /* scratch text ptr in window 1 */ text_ptr diff2; /* scratch text ptr in window 2 */ long rline1; /* real line number of diff pointer 1 */ long rline2; /* real line number of diff pointer 2 */ long bin_offset1; /* binary offset of diff pointer 1 */ long bin_offset2; /* binary offset of diff pointer 2 */ int len; /* line length variable */ register int tabs; /* local variable for mode.inflate_tabs, T or F */ char line_buff[(MAX_COLS+1)*2]; /* buffer for char and attribute */ /* * initialize the text pointers and the initial column. skip any * initial blank lines. */ rline1 = diff.rline1; rline2 = diff.rline2; node1 = diff.d1; node2 = diff.d2; bin_offset1 = diff.bin_offset1; bin_offset2 = diff.bin_offset2; tabs = mode.inflate_tabs; if (diff.blank_lines) { while (node1->len != EOF && is_line_blank( node1->line, node1->len )) { bin_offset1 += node1->len; node1 = node1->next; ++rline1; initial_rcol1 = 0; } while (node2->len != EOF && is_line_blank( node2->line , node2->len)) { bin_offset2 += node2->len; node2 = node2->next; ++rline2; initial_rcol2 = 0; } } /* * if everything is everything, initialize the diff variables and diff. */ if (node1->len != EOF && node2->len != EOF) { diff1 = node1->line; diff2 = node2->line; rcol1 = initial_rcol1; rcol2 = initial_rcol2; len1 = node1->len; len2 = node2->len; assert( rcol1 >= 0 ); assert( rcol1 < MAX_LINE_LENGTH ); assert( rcol2 >= 0 ); assert( rcol2 < MAX_LINE_LENGTH ); assert( len1 >= 0 ); assert( len1 < MAX_LINE_LENGTH ); assert( len2 >= 0 ); assert( len2 < MAX_LINE_LENGTH ); /* * if cursors are past EOL, move them back to EOL. */ len = find_end( diff1, len1 ); if (rcol1 > len) rcol1 = len; len = find_end( diff2, len2 ); if (rcol2 > len) rcol2 = len; /* * if skip leading space, make sure our cursors start on first non-space. */ if (diff.leading) { leading1 = skip_leading_space( diff1, len1 ); leading2 = skip_leading_space( diff2, len2 ); if (tabs) { leading1 = detab_adjust_rcol( diff1, leading1 ); leading2 = detab_adjust_rcol( diff2, leading2 ); } if (rcol1 < leading1) rcol1 = leading1; if (rcol2 < leading2) rcol2 = leading2; } /* * we now have a valid rcol for the diff start, we may need to adjust * for tabs, though. */ assert( rcol1 >= 0 ); assert( rcol1 < MAX_LINE_LENGTH ); assert( rcol2 >= 0 ); assert( rcol2 < MAX_LINE_LENGTH ); r1 = tabs ? entab_adjust_rcol( diff1, len1, rcol1 ) : rcol1; r2 = tabs ? entab_adjust_rcol( diff2, len2, rcol2 ) : rcol2; assert( r1 >= 0 ); assert( r1 <= len1 ); assert( r2 >= 0 ); assert( r2 <= len2 ); assert( r1 <= rcol1 ); assert( r2 <= rcol2 ); s_output( diff_message, g_display.mode_line, 67, g_display.diag_color ); while (node1->len != EOF && node2->len != EOF && !g_status.control_break) { /* * look at each character in each diff window */ c1 = (char)(r1 < len1 ? *(diff1 + r1) : 0); c2 = (char)(r2 < len2 ? *(diff2 + r2) : 0); /* * tabs == space */ if (tabs) { if (c1 == '\t') c1 = ' '; if (c2 == '\t') c2 = ' '; } /* * skip spaces, if needed */ if (diff.all_space) { while (c1 == ' ' && r1 < len1) { ++rcol1; r1 = tabs ? entab_adjust_rcol( diff1, len1, rcol1 ) : rcol1; c1 = (char)(r1 < len1 ? *(diff1 + r1) : 0); if (c1 == '\t' && tabs) c1 = ' '; } while (c2 == ' ' && r2 < len2) { ++rcol2; r2 = tabs ? entab_adjust_rcol( diff2, len2, rcol2 ) : rcol2; c2 = (char)(r2 < len2 ? *(diff2 + r2) : 0); if (c2 == '\t' && tabs) c2 = ' '; } } /* * if one of the node pointers has come to EOL, move to next * diff line. */ if (diff.ignore_eol) { if (r1 >= len1) { node1 = skip_eol( node1, &r1, &rcol1, &rline1, &bin_offset1 ); len1 = node1->len; if (len1 != EOF) { diff1 = node1->line; c1 = (char)(r1 < len1 ? *(diff1 + r1) : 0); if (c1 == '\t' && tabs) c1 = ' '; } } if (r2 >= len2) { node2 = skip_eol( node2, &r2, &rcol2, &rline2, &bin_offset2 ); len2 = node2->len; if (len2 != EOF) { diff2 = node2->line; c2 = (char)(r2 < len2 ? *(diff2 + r2) : 0); if (c2 == '\t' && tabs) c2 = ' '; } } } /* * convert the characters to lower case, if needed. */ if (mode.search_case == IGNORE) { c1 = (char)tolower( c1 ); c2 = (char)tolower( c2 ); } /* * diff each character in the diff lines until we reach EOL */ while (r1 < len1 && r2 < len2) { if (c1 == c2) { if (diff.all_space) { do { ++rcol1; r1 = tabs ? entab_adjust_rcol( diff1,len1,rcol1 ) : rcol1; c1 = (char)(r1 < len1 ? *(diff1 + r1) : 0); if (c1 == '\t' && tabs) c1 = ' '; } while (c1 == ' ' && r1 < len1); do { ++rcol2; r2 = tabs ? entab_adjust_rcol( diff2,len2,rcol2 ) : rcol2; c2 = (char)(r2 < len2 ? *(diff2 + r2) : 0); if (c2 == '\t' && tabs) c2 = ' '; } while (c2 == ' ' && r2 < len2); } else { ++rcol1; ++rcol2; r1 = tabs ? entab_adjust_rcol( diff1, len1, rcol1 ) : rcol1; r2 = tabs ? entab_adjust_rcol( diff2, len2, rcol2 ) : rcol2; c1 = (char)(r1 < len1 ? *(diff1 + r1) : 0); c2 = (char)(r2 < len2 ? *(diff2 + r2) : 0); if (tabs) { if (c1 == '\t') c1 = ' '; if (c2 == '\t') c2 = ' '; } } if (diff.ignore_eol) { if (r1 >= len1) { node1 = skip_eol(node1, &r1, &rcol1, &rline1,&bin_offset1); len1 = node1->len; if (len1 != EOF) { diff1 = node1->line; c1 = (char)(r1 < len1 ? *(diff1 + r1) : 0); if (c1 == '\t' && tabs) c1 = ' '; } } if (r2 >= len2) { node2 = skip_eol(node2, &r2, &rcol2, &rline2,&bin_offset2); len2 = node2->len; if (len2 != EOF) { diff2 = node2->line; c2 = (char)(r2 < len2 ? *(diff2 + r2) : 0); if (c2 == '\t' && tabs) c2 = ' '; } } } if (mode.search_case == IGNORE) { c1 = (char)tolower( c1 ); c2 = (char)tolower( c2 ); } } else { /* * when we show the diff, use rcol1 and rcol2, as * find_adjust does not adjust rcol for tabs. */ update_line( diff.w1 ); diff.w1->bin_offset = bin_offset1; find_adjust( diff.w1, node1, rline1, rcol1 ); check_virtual_col( diff.w1, rcol1, rcol1 ); show_diff_window( diff.w1 ); update_line( diff.w2 ); diff.w2->bin_offset = bin_offset2; bin_offset_adjust( diff.w2, rline2 ); find_adjust( diff.w2, node2, rline2, rcol2 ); check_virtual_col( diff.w2, rcol2, rcol2 ); show_diff_window( diff.w2 ); s_output( diff_blank, g_display.mode_line, 67, g_display.mode_color ); return( OK ); } } /* * if we haven't come to the end of a file buffer, check the last * characters. see if pointers are at EOL. */ if (node1->len != EOF && node2->len != EOF) { if (rcol1 != len1 && rcol2 != len2) { update_line( diff.w1 ); diff.w1->bin_offset = bin_offset1; find_adjust( diff.w1, node1, rline1, rcol1 ); show_diff_window( diff.w1 ); update_line( diff.w2 ); diff.w2->bin_offset = bin_offset2; find_adjust( diff.w2, node2, rline2, rcol2 ); show_diff_window( diff.w2 ); s_output( diff_blank, g_display.mode_line, 67, g_display.mode_color ); return( OK ); } else { node1 = skip_eol( node1, &r1, &rcol1, &rline1, &bin_offset1 ); len1 = node1->len; diff1 = node1->line; node2 = skip_eol( node2, &r2, &rcol2, &rline2, &bin_offset2 ); len2 = node2->len; diff2 = node2->line; } } assert( rcol1 >= 0 ); assert( rcol1 < MAX_LINE_LENGTH ); assert( rcol2 >= 0 ); assert( rcol2 < MAX_LINE_LENGTH ); assert( r1 >= 0 ); assert( r1 < MAX_LINE_LENGTH ); assert( r2 >= 0 ); assert( r2 < MAX_LINE_LENGTH ); assert( r1 <= rcol1 ); assert( r2 <= rcol2 ); if (node1->len == EOF) assert( len1 == EOF ); else { assert( len1 >= 0 ); assert( len1 < MAX_LINE_LENGTH ); } if (node2->len == EOF) assert( len2 == EOF ); else { assert( len2 >= 0 ); assert( len2 < MAX_LINE_LENGTH ); } } save_screen_line( 0, bottom, line_buff ); set_prompt( diff_prompt4, bottom ); getkey( ); restore_screen_line( 0, bottom, line_buff ); s_output( diff_blank, g_display.mode_line, 67, g_display.mode_color ); } return( ERROR ); }
/* * Name: setup_directory_window * Purpose: set number of rows and cols in directory window * Date: February 13, 1992 * Passed: dir: pointer to directory structure * cnt: number of files * Notes: set up stuff we need to know about how to display files. */ void setup_directory_window( DIRECTORY *dir, int cnt ) { int i; int wid; char temp[MAX_COLS]; /* line to output */ /* * setup the fixed vars used in dir display. * dir->col = physical upper left column of dir screen * dir->row = physical upper left row or line of dir screen * dir->wid = width of physical screen * dir->hgt = height of physical screen * dir->max_cols number of columns of files in dir screen * dir->max_lines number of lines of files in each column in dir screen * dir->cnt number of files in list */ dir->col = 3; dir->row = 5; wid = dir->wid = 72; dir->hgt = 16; dir->max_cols = 5; dir->max_lines = 9; dir->cnt = cnt; /* * Find out how many lines in each column are needed to display * matching files. */ dir->lines = dir->cnt / dir->max_cols + (dir->cnt % dir->max_cols ? 1 : 0); if (dir->lines > dir->max_lines) dir->lines = dir->max_lines; /* * Find out how many columns of file names we need. */ dir->cols = dir->cnt / dir->lines + (dir->cnt % dir->lines ? 1 : 0); if (dir->cols > dir->max_cols) dir->cols = dir->max_cols; /* * Find the maximun number of file names we can display in help screen. */ dir->avail = dir->lines * dir->cols; /* * Now find the number of file names we do have on the screen. Every * time we slide the "window", we have to calculate a new nfiles. */ dir->nfiles = dir->cnt > dir->avail ? dir->avail : dir->cnt; /* * A lot of times, the number of matching files will not fit evenly * in our help screen. The last column on the right will be partially * filled, hence the variable name prow (partial row). When there are * more file names than can fit on the screen, we have to calculate * prow every time we slide the "window" of files. */ dir->prow = dir->lines - (dir->avail - dir->nfiles); /* * Find out how many "virtual" columns of file names we have. If * all the files can fit in the dir screen, there will be no * virtual columns. */ if (dir->cnt < dir->avail) dir->vcols = 0; else dir->vcols = (dir->cnt - dir->avail) / dir->max_lines + ((dir->cnt - dir->avail) % dir->max_lines ? 1 : 0); /* * Find the physical display column in dir screen. */ dir->flist_col[0] = dir->col + 2; for (i=1; i<dir->max_cols; i++) dir->flist_col[i] = dir->flist_col[i-1] + 14; /* * Now, draw the borders of the dir screen. */ for (i=0; i < dir->hgt; i++) { if (i == 0 || i == dir->hgt-1) { memset( temp, 'Ä', wid ); temp[wid] = '\0'; if (i == 0) { temp[0] = 'Ú'; temp[wid-1] = '¿'; } else { temp[0] = 'À'; temp[wid-1] = 'Ù'; } } else { memset( temp, ' ', wid ); temp[wid] = '\0'; temp[0] = temp[wid-1] = '³'; } s_output( temp, dir->row+i, dir->col, g_display.help_color ); } /* * Write headings in help screen. */ s_output( dir4, dir->row+1, dir->col+3, g_display.help_color ); s_output( dir5, dir->row+2, dir->col+3, g_display.help_color ); s_output( dir6, dir->row+2, dir->col+44, g_display.help_color ); s_output( dir7, dir->row+14, dir->col+8, g_display.help_color ); }
int main(int argc, char **argv) { struct commandline cmd; (void) memset((char *) &cmd, 0, sizeof(struct commandline)); clear_args(); if (!parseargs(argc, argv, &cmd)) usage(); if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag || cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) { checkfiles(cmd.infile, cmd.outfile); } else checkfiles(cmd.infile, NULL); if (cmd.cflag) { c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile); } else if (cmd.hflag) { h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile); } else if (cmd.lflag) { l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile); } else if (cmd.sflag || cmd.mflag || (cmd.nflag)) { s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND, cmd.outfile, cmd.mflag, cmd.nflag); } else if (cmd.tflag) { t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile); } else if (cmd.Ssflag) { svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile); } else if (cmd.Scflag) { clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile); } else { /* the rescans are required, since cpp may effect input */ c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c"); reinitialize(); h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h"); reinitialize(); l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c"); reinitialize(); if (inetdflag || !tirpcflag) s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND, "_svc.c", cmd.mflag, cmd.nflag); else s_output(allnc, allnv, cmd.infile, "-DRPC_SVC", EXTEND, "_svc.c", cmd.mflag, cmd.nflag); if (tblflag) { reinitialize(); t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i"); } if (allfiles) { reinitialize(); svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c"); } if (allfiles) { reinitialize(); clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c"); } } exit(nonfatalerrors); /* NOTREACHED */ }
bool SHM_Transporter::connect_client_impl(NDB_SOCKET_TYPE sockfd) { DBUG_ENTER("SHM_Transporter::connect_client_impl"); SocketInputStream s_input(sockfd); SocketOutputStream s_output(sockfd); char buf[256]; // Wait for server to create and attach DBUG_PRINT("info", ("Wait for server to create and attach")); if (s_input.gets(buf, 256) == 0) { NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("error", ("Server id %d did not attach", remoteNodeId)); DBUG_RETURN(false); } if(sscanf(buf, "shm server 1 ok: %d", &m_remote_pid) != 1) { NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(false); } // Create if(!_shmSegCreated){ if (!ndb_shm_get()) { NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("error", ("Failed create of shm seg to node %d", remoteNodeId)); DBUG_RETURN(false); } _shmSegCreated = true; } // Attach if(!_attached){ if (!ndb_shm_attach()) { make_error_info(buf, sizeof(buf)); report_error(TE_SHM_UNABLE_TO_ATTACH_SEGMENT, buf); NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("error", ("Failed attach of shm seg to node %d", remoteNodeId)); DBUG_RETURN(false); } _attached = true; } // Send ok to server s_output.println("shm client 1 ok: %d", m_transporter_registry.m_shm_own_pid); int r= connect_common(sockfd); if (r) { // Wait for ok from server DBUG_PRINT("info", ("Wait for ok from server")); if (s_input.gets(buf, 256) == 0) { NDB_CLOSE_SOCKET(sockfd); DBUG_PRINT("error", ("No ok from server node %d", remoteNodeId)); DBUG_RETURN(false); } // Send ok to server s_output.println("shm client 2 ok"); DBUG_PRINT("info", ("Successfully connected client to node %d", remoteNodeId)); } NDB_CLOSE_SOCKET(sockfd); DBUG_RETURN(r); }
void new_assignment_help( HELP_WINDOW *hw, char *help[], struct screen *help_heading, int *ch ) { int col, row, i; int update_name, change_color, draw_page; save_and_draw( hw, help_heading, &w_ptr ); show_func_list( hw, help ); col = hw->ulft_col + hw->dply_col; row = hw->ulft_row + hw->dply_row + hw->v_row; change_color = TRUE; *ch = 0; while (*ch!=RTURN && *ch!=ESC) { draw_page = FALSE; position_cursor( hw, hw->line_length, &update_name, &change_color, ch ); switch (*ch) { case PGUP : if (hw->select > hw->avail_lines-1) { hw->select = hw->select - hw->avail_lines; if (hw->v_row > hw->select) hw->select = hw->v_row; draw_page = TRUE; } else if (hw->select - hw->v_row > 0) { hw->select = hw->v_row; draw_page = TRUE; } break; case PGDN : if (hw->select + hw->avail_lines < hw->num_entries) { hw->select = hw->select + hw->avail_lines; draw_page = TRUE; } else if (hw->select + hw->avail_lines - hw->v_row < hw->num_entries) { hw->select = hw->num_entries - 1; draw_page = TRUE; } if ((hw->num_entries - 1) - hw->select < hw->avail_lines && draw_page) { i = row - hw->v_row; scroll_window( 0, i, col, i+hw->avail_lines-1, col+hw->line_length, NORMAL ); } break; } if (draw_page == TRUE) { show_func_list( hw, help ); update_name = TRUE; change_color = TRUE; } row = hw->ulft_row + hw->dply_row + hw->v_row; if (update_name) s_output( help[hw->select], row, col, NORMAL ); if (change_color) hlight_line( col, row, hw->line_length, cfg.attr ); *ch = getkey( ); change_color = FALSE; } window_control( &w_ptr, RESTORE, hw->ulft_col, hw->ulft_row, hw->total_col, hw->total_row ); if (*ch != RTURN) *ch = 0; }
void master_help( HELP_WINDOW *hw, KEY_DEFS *help, struct screen *help_heading, char *t, int *ch ) { FILE *fp; int col, row, i, j; int update_name, change_color, draw_page; char str[80]; char *blank = " "; char temp[20]; HELP_WINDOW hw_k; xygoto( -1, -1 ); save_and_draw( hw, help_heading, &w_ptr ); show_key_def_list( hw, help ); col = hw->ulft_col + hw->dply_col; row = hw->ulft_row + hw->dply_row + hw->v_row; change_color = TRUE; *ch = 0; while (*ch!=F3 && *ch != F10 && *ch!=ESC) { draw_page = FALSE; position_cursor( hw, hw->line_length, &update_name, &change_color, ch ); switch (*ch) { case PGUP : if (hw->select > hw->avail_lines-1) { hw->select = hw->select - hw->avail_lines; if (hw->v_row > hw->select) hw->select = hw->v_row; draw_page = TRUE; } else if (hw->select - hw->v_row > 0) { hw->select = hw->v_row; draw_page = TRUE; } break; case PGDN : if (hw->select + hw->avail_lines < hw->num_entries) { hw->select = hw->select + hw->avail_lines; draw_page = TRUE; } else if (hw->select + hw->avail_lines - hw->v_row < hw->num_entries) { hw->select = hw->num_entries - 1; draw_page = TRUE; } if ((hw->num_entries - 1) - hw->select < hw->avail_lines && draw_page) { i = row - hw->v_row; scroll_window( 0, i, col, i+hw->avail_lines-1, col+hw->line_length, NORMAL ); } break; case F5 : hw_k.dply_col = 2; hw_k.dply_row = 3; hw_k.line_length = 33; hw_k.avail_lines = 6; hw_k.v_row = 0; hw_k.select = 0; hw_k.num_entries = NUM_FUNC; hw_k.ulft_col = 20; hw_k.ulft_row = row + 1; if (hw_k.ulft_row > 12) hw_k.ulft_row = row - 12; hw_k.total_col = 37; hw_k.total_row = 12; new_assignment_help( &hw_k, avail_func, func_head, ch ); if (*ch == RTURN) { help[hw->select].key[0] = '*'; help[hw->select].func_index = (unsigned char)hw_k.select; s_output( help[hw->select].key, row, col, cfg.attr ); s_output( " ", row, col+31, cfg.attr ); s_output( avail_func[help[hw->select].func_index], row, col+31, cfg.attr ); *ch = 0; } break; case F7 : hw_k.ulft_col = 14; hw_k.ulft_row = 10; hw_k.total_col = 52; hw_k.total_row = 5; save_and_draw( &hw_k, file_head, &w_ptr ); xygoto( hw_k.ulft_col+28, hw_k.ulft_row+2 ); gets( str ); j = TRUE; if ((i = access( str, EXIST )) == 0) { s_output( blank, hw_k.ulft_row+2, hw_k.ulft_col+1, NORMAL ); s_output( "OK to overwrite exiting file (y/n)?", hw_k.ulft_row+2, hw_k.ulft_col+1, NORMAL ); xygoto( hw_k.ulft_col+38, hw_k.ulft_row+2 ); i = getkey( ); while (i != 'Y' && i != 'y' && i != 'N' && i != 'n') i = getkey( ); if (i == 'n' || i == 'N') j = FALSE; } xygoto( -1, -1 ); if (j == TRUE && (fp = fopen( str, "w" )) != NULL) { for (i=0; i<hw->num_entries && j; i++) { fprintf( fp, " %22s = ", help[i].key+3 ); fprintf( fp, " %s\n", avail_func[help[i].func_index] ); } fclose( fp ); } else { s_output( blank, hw_k.ulft_row+2, hw_k.ulft_col+1, NORMAL ); s_output( "Cannot open file. Press any key to contine.", hw_k.ulft_row+2, hw_k.ulft_col+1, NORMAL ); j = getkey( ); } window_control( &w_ptr, RESTORE, hw_k.ulft_col, hw_k.ulft_row, hw_k.total_col, hw_k.total_row ); break; case F8 : if ((fp = fopen( "PRN", "a" )) != NULL) { hw_k.ulft_col = 20; hw_k.ulft_row = 10; hw_k.total_col = 42; hw_k.total_row = 5; save_and_draw( &hw_k, print_head, &w_ptr ); j = TRUE; for (i=0; i<hw->num_entries && j; i++) { itoa( i+1, temp, 10 ); s_output( temp, hw_k.ulft_row+2, hw_k.ulft_col+16, NORMAL ); fprintf( fp, " %22s = ", help[i].key+3 ); fprintf( fp, " %s\n", avail_func[help[i].func_index] ); if (kbhit()) { j = getkey( ); if (j == ESC) j = FALSE; else j = TRUE; } } fprintf( fp, "\f" ); fclose( fp ); window_control( &w_ptr, RESTORE, hw_k.ulft_col, hw_k.ulft_row, hw_k.total_col, hw_k.total_row ); } break; } if (draw_page == TRUE) { show_key_def_list( hw, help ); update_name = TRUE; change_color = TRUE; } row = hw->ulft_row + hw->dply_row + hw->v_row; if (update_name) { s_output( help[hw->select].key, row, col, NORMAL ); s_output( avail_func[help[hw->select].func_index], row, col+31, NORMAL ); } if (change_color) hlight_line( col, row, hw->line_length, cfg.attr ); *ch = getkey( ); change_color = FALSE; } window_control( &w_ptr, RESTORE, hw->ulft_col, hw->ulft_row, hw->total_col, hw->total_row ); }