void SessionImpl::transmit( const Response& response, const function< void ( const error_code&, size_t ) >& callback ) const { auto hdrs = m_settings->get_default_headers( ); if ( m_resource not_eq nullptr ) { const auto m_resource_headers = m_resource->m_pimpl->m_default_headers; hdrs.insert( m_resource_headers.begin( ), m_resource_headers.end( ) ); } hdrs.insert( m_headers.begin( ), m_headers.end( ) ); auto response_headers = response.get_headers( ); hdrs.insert( response_headers.begin( ), response_headers.end( ) ); auto payload = make_shared< Response >( ); payload->set_headers( hdrs ); payload->set_body( response.get_body( ) ); payload->set_version( response.get_version( ) ); payload->set_protocol( response.get_protocol( ) ); payload->set_status_code( response.get_status_code( ) ); payload->set_status_message( response.get_status_message( ) ); if ( payload->get_status_message( ).empty( ) ) { payload->set_status_message( m_settings->get_status_message( payload->get_status_code( ) ) ); } m_request->m_pimpl->m_socket->start_write( Http::to_bytes( payload ), callback ); }
void ICMPv4::ping_reply(full_header* full_hdr, uint16_t size) { auto packet_ptr = inet_.create_packet(size); auto buf = packet_ptr->buffer(); icmp_header* hdr = &reinterpret_cast<full_header*>(buf)->icmp_hdr; hdr->type = ICMP_ECHO_REPLY; hdr->code = 0; hdr->identifier = full_hdr->icmp_hdr.identifier; hdr->sequence = full_hdr->icmp_hdr.sequence; debug("<ICMP> Rest of header IN: 0x%lx OUT: 0x%lx\n", full_hdr->icmp_hdr.rest, hdr->rest); debug("<ICMP> Transmitting answer\n"); // Populate response IP header auto ip4_pckt = static_unique_ptr_cast<PacketIP4>(std::move(packet_ptr)); ip4_pckt->init(); ip4_pckt->set_src(full_hdr->ip_hdr.daddr); ip4_pckt->set_dst(full_hdr->ip_hdr.saddr); ip4_pckt->set_protocol(IP4::IP4_ICMP); ip4_pckt->set_ip_data_length(sizeof(icmp_header) + size - sizeof(full_header)); // Copy payload from old to new packet uint8_t* payload = reinterpret_cast<uint8_t*>(hdr) + sizeof(icmp_header); uint8_t* source = reinterpret_cast<uint8_t*>(&full_hdr->icmp_hdr) + sizeof(icmp_header); memcpy(payload, source, size - sizeof(full_header)); hdr->checksum = 0; hdr->checksum = net::checksum(reinterpret_cast<uint16_t*>(hdr), size - sizeof(full_header) + sizeof(icmp_header)); network_layer_out_(std::move(ip4_pckt)); }
static int usb_mouse_setup(struct usbdevice_s *usbdev , struct usb_endpoint_descriptor *epdesc) { if (! CONFIG_USB_MOUSE) return -1; if (mouse_pipe) // XXX - this enables the first found mouse (could be random) return -1; if (epdesc->wMaxPacketSize < 3 || epdesc->wMaxPacketSize > 8) return -1; // Enable "boot" protocol. int ret = set_protocol(usbdev->defpipe, 0); if (ret) return -1; mouse_pipe = usb_alloc_pipe(usbdev, epdesc); if (!mouse_pipe) return -1; dprintf(1, "USB mouse initialized\n"); return 0; }
static int usb_kbd_setup(struct usbdevice_s *usbdev , struct usb_endpoint_descriptor *epdesc) { if (! CONFIG_USB_KEYBOARD) return -1; if (keyboard_pipe) // XXX - this enables the first found keyboard (could be random) return -1; if (epdesc->wMaxPacketSize != 8) return -1; // Enable "boot" protocol. int ret = set_protocol(usbdev->defpipe, 0); if (ret) return -1; // Periodically send reports to enable key repeat. ret = set_idle(usbdev->defpipe, KEYREPEATMS); if (ret) return -1; keyboard_pipe = usb_alloc_pipe(usbdev, epdesc); if (!keyboard_pipe) return -1; dprintf(1, "USB keyboard initialized\n"); return 0; }
void RedClient::set_target(const std::string& host, int port, int sport, int protocol) { if (protocol != get_protocol()) { LOG_INFO("old protocol %d, new protocol %d", get_protocol(), protocol); } _port = port; _sport = sport; _host.assign(host); set_protocol(protocol); }
void forge_ipv4_header( void* buf , struct sockaddr* destination , uint8_t protonum ) { ipv4_header_t* iph = (ipv4_header_t*) buf; memset( buf , 0 , sizeof( ipv4_header_t ) ); iph->version = 4; iph->IHL= 5; set_destination( iph ,(struct sockaddr_in *) destination ); set_source( iph , inet_addr(SOURCEIP) ); set_TTL(iph, 80); set_protocol( iph, protonum ); set_packet_length( iph , 28 );//taille d'un echo request set_ipv4_checksum( iph ); }
//! initializes to a default, empty UDP packet, given //! a valid MTU-sized buffer void init() { PacketIP4::init(); // source and destination ports header().sport = 0; header().dport = 0; // set zero length set_length(0); // zero the optional checksum header().checksum = 0; // set UDP payload location (!?) payload_ = buffer() + sizeof(UDP::full_header); set_protocol(IP4::IP4_UDP); }
void init(uint16_t l_port, uint16_t d_port) { Expects(data_end() == layer_begin() + ip_header_length()); // Initialize UDP packet header // source and destination ports set_src_port(l_port); set_dst_port(d_port); // set zero length set_length(sizeof(UDP::header)); // zero the optional checksum header().checksum = 0; set_protocol(Protocol::UDP); }
void SystemExpressionRepresentationScreenWidth::assign_value( ExpressionRepresentation *new_value ) { int width = new_value->asInt(); if( width < 32 || width > MSCREENWIDTH ) error( FormatString("terminal-width must be > 32 and <= %d") << MSCREENWIDTH ); else { term_width = width; theActiveView->t_width = width; theActiveView->t_change_width( width ); set_protocol( protocol_mode ); theActiveView->fit_windows_to_screen(); screen_garbaged = 1; } }
void SystemExpressionRepresentationScreenLength::assign_value( ExpressionRepresentation *new_value ) { int length = new_value->asInt(); if( length < 3 || length > MSCREENLENGTH ) error( FormatString("terminal-length must be > 3 and <= %d") << MSCREENLENGTH ); else { term_length = length; theActiveView->t_length = length; set_protocol( protocol_mode ); theActiveView->fit_windows_to_screen(); screen_garbaged = 1; } }
Connection::Connection(void) : init_ok_(0), last_recv_time_(time(NULL)), last_send_time_(time(NULL)), last_error_(0), auto_release_(0), state_(CLOSED), default_event_handler_("ConnDefHandler"), connection_manager_(NULL), event_handler_(&default_event_handler_) { set_ip(0U); set_port(0U); set_protocol("tcp"); }
void Url::parseProtocol(const char*& url) { const char* p = url; char ch; while ((ch = *p) && (qisascii(ch) || qisdigit(ch) || ch == '.' || ch == '+' || ch == '-')) p++; if (ch == ':') { p++; exlib::string str(url, p - url); set_protocol(str); url = p; } }
result_t Url::format(v8::Local<v8::Object> args) { clear(); Isolate* isolate = holder(); exlib::string str; v8::Local<v8::Value> v; if (getString(isolate, args, "protocol", str)) set_protocol(str); if (getString(isolate, args, "username", str)) set_username(str); if (getString(isolate, args, "password", str)) set_password(str); if (getString(isolate, args, "host", str)) set_host(str); if (getString(isolate, args, "port", str)) set_port(str); if (getString(isolate, args, "hostname", str)) set_hostname(str); if (getString(isolate, args, "pathname", str)) set_pathname(str); v = args->Get(holder()->NewString("query")); if (!IsEmpty(v)) set_query(v); if (getString(isolate, args, "hash", str)) set_hash(str); if (m_slashes && m_protocol.compare("file:") && m_hostname.length() == 0) m_slashes = false; v = args->Get(holder()->NewString("slashes")); if (!IsEmpty(v)) set_slashes(v->BooleanValue()); return 0; }
static void *ds3_init(void *handle) { ds3_instance_t *instance; int errors = 0; RARCH_LOG("[ds3]: init\n"); instance = (ds3_instance_t *)calloc(1, sizeof(ds3_instance_t)); if(!instance) goto error; memset(instance, 0, sizeof(ds3_instance_t)); instance->handle = handle; RARCH_LOG("[ds3]: setting protocol\n"); /* this might fail, but we don't care. */ set_protocol(instance, 1); RARCH_LOG("[ds3]: sending control packet\n"); if(send_control_packet(instance) < 0) errors++; RARCH_LOG("[ds3]: sending activation packet\n"); if(send_activation_packet(instance) < 0) errors++; if(errors) goto error; instance->pad = hid_pad_register(instance, &ds3_pad_connection); if(!instance->pad) goto error; RARCH_LOG("[ds3]: init complete.\n"); return instance; error: RARCH_ERR("[ds3]: init failed.\n"); if(instance) free(instance); return NULL; }
Connection::Connection( const char* string_ip, uint16_t port, EventHandler* event_handler) : init_ok_(0), last_recv_time_(time(NULL)), last_send_time_(time(NULL)), last_error_(0), auto_release_(0), state_(CLOSED), default_event_handler_("ConnDefHandler"), connection_manager_(NULL) { set_ip(string_ip); set_port(port); set_protocol("tcp"); if (NULL == event_handler) { event_handler_ = &default_event_handler_; } else { event_handler_ = event_handler; } }
static struct ir_remote * read_config_recursive(FILE *f, const char *name, int depth) { char buf[LINE_LEN+1], *key, *val, *val2; int len,argc; struct ir_remote *top_rem=NULL,*rem=NULL; struct void_array codes_list,raw_codes,signals; struct ir_ncode raw_code={NULL,0,0,NULL}; struct ir_ncode name_code={NULL,0,0,NULL}; struct ir_ncode *code; int mode=ID_none; line=0; parse_error=0; LOGPRINTF(2, "parsing '%s'", name); while(fgets(buf,LINE_LEN,f)!=NULL) { line++; len=strlen(buf); if(len==LINE_LEN && buf[len-1]!='\n') { logprintf(LOG_ERR,"line %d too long in config file", line); parse_error=1; break; } if(len>0) { len--; if(buf[len]=='\n') buf[len]=0; } if(len>0) { len--; if(buf[len]=='\r') buf[len]=0; } /* ignore comments */ if(buf[0]=='#'){ continue; } key=strtok(buf, whitespace); /* ignore empty lines */ if(key==NULL) continue; val=strtok(NULL, whitespace); if(val!=NULL){ val2=strtok(NULL, whitespace); LOGPRINTF(3,"\"%s\" \"%s\"",key,val); if (strcasecmp("include",key)==0){ FILE* childFile; const char *childName; const char *fullPath; char result[FILENAME_MAX+1]; if (depth > MAX_INCLUDES) { logprintf(LOG_ERR,"error opening child file defined at %s:%d",name,line); logprintf(LOG_ERR,"too many files included"); parse_error=-1; break; } childName = lirc_parse_include(val); if (!childName){ logprintf(LOG_ERR,"error parsing child file value defined at line %d:",line); logprintf(LOG_ERR,"invalid quoting"); parse_error=-1; break; } fullPath = lirc_parse_relative(result, sizeof(result), childName, name); if (!fullPath) { logprintf(LOG_ERR,"error composing relative file path defined at line %d:",line); logprintf(LOG_ERR,"resulting path too long"); parse_error=-1; break; } childFile = fopen(fullPath, "r"); if (childFile == NULL){ logprintf(LOG_ERR,"error opening child file '%s' defined at line %d:",fullPath, line); logprintf(LOG_ERR,"ignoring this child file for now."); } else{ int save_line = line; if (!top_rem){ /* create first remote */ LOGPRINTF(2,"creating first remote"); rem = read_config_recursive(childFile, fullPath, depth + 1); if(rem != (void *) -1 && rem != NULL) { top_rem = rem; } else { rem = NULL; } }else{ /* create new remote */ LOGPRINTF(2,"creating next remote"); rem->next=read_config_recursive(childFile, fullPath, depth + 1); if(rem->next != (void *) -1 && rem->next != NULL) { rem=rem->next; } else { rem->next = NULL; } } fclose(childFile); line = save_line; } }else if (strcasecmp("begin",key)==0){ if (strcasecmp("codes", val)==0){ /* init codes mode */ LOGPRINTF(2," begin codes"); if (!checkMode(mode, ID_remote, "begin codes")) break; if (rem->codes){ logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"codes are already defined"); parse_error=1; break; } init_void_array(&codes_list,30, sizeof(struct ir_ncode)); mode=ID_codes; }else if(strcasecmp("raw_codes",val)==0){ /* init raw_codes mode */ LOGPRINTF(2," begin raw_codes"); if(!checkMode(mode, ID_remote, "begin raw_codes")) break; if (rem->codes){ logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"codes are already defined"); parse_error=1; break; } set_protocol(rem, RAW_CODES); raw_code.code=0; init_void_array(&raw_codes,30, sizeof(struct ir_ncode)); mode=ID_raw_codes; }else if(strcasecmp("remote",val)==0){ /* create new remote */ LOGPRINTF(1,"parsing remote"); if(!checkMode(mode, ID_none, "begin remote")) break; mode=ID_remote; if (!top_rem){ /* create first remote */ LOGPRINTF(2,"creating first remote"); rem=top_rem=s_malloc(sizeof(struct ir_remote)); }else{ /* create new remote */ LOGPRINTF(2,"creating next remote"); rem->next=s_malloc(sizeof(struct ir_remote));; rem=rem->next; } }else if(mode==ID_codes){ code=defineCode(key, val, &name_code); while(!parse_error && val2!=NULL) { struct ir_code_node *node; if(val2[0]=='#') break; /* comment */ node=defineNode(code, val2); val2=strtok(NULL, whitespace); } code->current=NULL; add_void_array(&codes_list, code); }else{ logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"unknown section \"%s\"",val); parse_error=1; } if(!parse_error && val2!=NULL) { logprintf(LOG_WARNING,"garbage after " "'%s' token in line %d ignored", val,line); } }else if (strcasecmp("end",key)==0){ if (strcasecmp("codes", val)==0){ /* end Codes mode */ LOGPRINTF(2," end codes"); if (!checkMode(mode, ID_codes, "end codes")) break; rem->codes=get_void_array(&codes_list); mode=ID_remote; /* switch back */ }else if(strcasecmp("raw_codes",val)==0){ /* end raw codes mode */ LOGPRINTF(2," end raw_codes"); if(mode==ID_raw_name){ raw_code.signals=get_void_array(&signals); raw_code.length=signals.nr_items; if(raw_code.length%2==0) { logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"bad signal length"); parse_error=1; } if(!add_void_array(&raw_codes, &raw_code)) break; mode=ID_raw_codes; } if(!checkMode(mode,ID_raw_codes, "end raw_codes")) break; rem->codes=get_void_array(&raw_codes); mode=ID_remote; /* switch back */ }else if(strcasecmp("remote",val)==0){ /* end remote mode */ LOGPRINTF(2,"end remote"); /* print_remote(rem); */ if (!checkMode(mode,ID_remote, "end remote")) break; if(!sanityChecks(rem)) { parse_error=1; break; } # ifdef DYNCODES if(rem->dyncodes_name==NULL) { rem->dyncodes_name=s_strdup("unknown"); } rem->dyncodes[0].name=rem->dyncodes_name; rem->dyncodes[1].name=rem->dyncodes_name; # endif /* not really necessary because we clear the alloced memory */ rem->next=NULL; rem->last_code=NULL; mode=ID_none; /* switch back */ }else if(mode==ID_codes){ code=defineCode(key, val, &name_code); while(!parse_error && val2!=NULL) { struct ir_code_node *node; if(val2[0]=='#') break; /* comment */ node=defineNode(code, val2); val2=strtok(NULL, whitespace); } code->current=NULL; add_void_array(&codes_list, code); }else{ logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"unknown section %s",val); parse_error=1; } if(!parse_error && val2!=NULL) { logprintf(LOG_WARNING,"garbage after '%s'" " token in line %d ignored", val,line); } } else { switch (mode){ case ID_remote: argc=defineRemote(key, val, val2, rem); if(!parse_error && ((argc==1 && val2!=NULL) || (argc==2 && val2!=NULL && strtok(NULL, whitespace)!=NULL))) { logprintf(LOG_WARNING,"garbage after '%s'" " token in line %d ignored", key,line); } break; case ID_codes: code=defineCode(key, val, &name_code); while(!parse_error && val2!=NULL) { struct ir_code_node *node; if(val2[0]=='#') break; /* comment */ node=defineNode(code, val2); val2=strtok(NULL, whitespace); } code->current=NULL; add_void_array(&codes_list, code); break; case ID_raw_codes: case ID_raw_name: if(strcasecmp("name",key)==0){ LOGPRINTF(3,"Button: \"%s\"",val); if(mode==ID_raw_name) { raw_code.signals=get_void_array(&signals); raw_code.length=signals.nr_items; if(raw_code.length%2==0) { logprintf(LOG_ERR,"error in configfile line %d:",line); logprintf(LOG_ERR,"bad signal length"); parse_error=1; } if(!add_void_array(&raw_codes, &raw_code)) break; } if(!(raw_code.name=s_strdup(val))){ break; } raw_code.code++; init_void_array(&signals,50,sizeof(lirc_t)); mode=ID_raw_name; if(!parse_error && val2!=NULL) { logprintf(LOG_WARNING,"garbage after '%s'" " token in line %d ignored", key,line); } }else{ if(mode==ID_raw_codes) { logprintf(LOG_ERR,"no name for signal defined at line %d",line); parse_error=1; break; } if(!addSignal(&signals, key)) break; if(!addSignal(&signals, val)) break; if (val2){ if (!addSignal(&signals, val2)){ break; } } while ((val=strtok(NULL, whitespace))){ if (!addSignal(&signals, val)) break; } } break; } } }else if(mode==ID_raw_name){ if(!addSignal(&signals, key)){ break; } }else{ logprintf(LOG_ERR,"error in configfile line %d", line); parse_error=1; break; } if (parse_error){ break; } } if(mode!=ID_none) { switch(mode) { case ID_raw_name: if(raw_code.name!=NULL) { free(raw_code.name); if(get_void_array(&signals)!=NULL) free(get_void_array(&signals)); } case ID_raw_codes: rem->codes=get_void_array(&raw_codes); break; case ID_codes: rem->codes=get_void_array(&codes_list); break; } if(!parse_error) { logprintf(LOG_ERR,"unexpected end of file"); parse_error=1; } } if (parse_error){ static int print_error = 1; if(print_error) { logprintf(LOG_ERR, "reading of file '%s' failed", name); print_error = 0; } free_config(top_rem); if(depth == 0) print_error = 1; return((void *) -1); } /* kick reverse flag */ /* handle RC6 flag to be backwards compatible: previous RC-6 config files did not set rc6_mask */ rem=top_rem; while(rem!=NULL) { if((!is_raw(rem)) && rem->flags&REVERSE) { struct ir_ncode *codes; if(has_pre(rem)) { rem->pre_data=reverse(rem->pre_data, rem->pre_data_bits); } if(has_post(rem)) { rem->post_data=reverse(rem->post_data, rem->post_data_bits); } codes=rem->codes; while(codes->name!=NULL) { codes->code=reverse(codes->code,rem->bits); codes++; } rem->flags=rem->flags&(~REVERSE); rem->flags=rem->flags|COMPAT_REVERSE; /* don't delete the flag because we still need it to remain compatible with older versions */ } if(rem->flags&RC6 && rem->rc6_mask==0 && rem->toggle_bit>0) { int all_bits=bit_count(rem); rem->rc6_mask=((ir_code) 1)<<(all_bits-rem->toggle_bit); } if(rem->toggle_bit > 0) { int all_bits=bit_count(rem); if(has_toggle_bit_mask(rem)) { logprintf(LOG_WARNING, "%s uses both toggle_bit and " "toggle_bit_mask", rem->name); } else { rem->toggle_bit_mask=((ir_code) 1)<<(all_bits-rem->toggle_bit); } rem->toggle_bit = 0; } if(has_toggle_bit_mask(rem)) { if(!is_raw(rem) && rem->codes) { rem->toggle_bit_mask_state = (rem->codes->code & rem->toggle_bit_mask); if(rem->toggle_bit_mask_state) { /* start with state set to 0 for backwards compatibility */ rem->toggle_bit_mask_state ^= rem->toggle_bit_mask; } } } if(is_serial(rem)) { lirc_t base; if(rem->baud>0) { base=1000000/rem->baud; if(rem->pzero==0 && rem->szero==0) { rem->pzero=base; } if(rem->pone==0 && rem->sone==0) { rem->sone=base; } } if(rem->bits_in_byte==0) { rem->bits_in_byte=8; } } if(rem->min_code_repeat>0) { if(!has_repeat(rem) || rem->min_code_repeat>rem->min_repeat) { logprintf(LOG_WARNING, "invalid min_code_repeat value"); rem->min_code_repeat = 0; } } calculate_signal_lengths(rem); rem=rem->next; } top_rem = sort_by_bit_count(top_rem); # if defined(DEBUG) && !defined(DAEMONIZE) /*fprint_remotes(stderr, top_rem);*/ # endif return (top_rem); }
static int set_general(struct sc_stream* stream, char* stream_str) { int rc = 0; uint8_t mac[6]; char* key; char* next_field = stream_str; /* General format is series of key=value pairs, separated by ",". */ while( next_field && (rc == 0) ) { char* value; char* field; field = strsep(&next_field, ","); /* Split key and value */ value = field; key = strsep(&value, "="); if( !value ) { /* Handle some key-only magic values */ if( !strcmp(key, "all") ) rc = sc_stream_all(stream); /* The following needs a strncmp because we pass the stream as * 'sniff [0,1]' */ else if( !strncmp(key, "sniff", strlen("sniff")) ) rc = sc_stream_sniff(stream, key); else if( !strcmp(key, "ip") ) rc = set_eth_type(stream, key); else if( !strcmp(key, "udp") || !strcmp(key, "tcp") ) rc = set_protocol(stream, key); else { fprintf(stderr, "%s: ERROR: No value for key %s\n", __func__, key); return -EINVAL; } } else { if( !strcmp(key, "dmac") ) { if( parse_mac(value, mac) < 0 ) { fprintf(stderr, "%s: ERROR: Failed to parse mac \"%s\"\n", __func__, key); return -EINVAL; } rc = sc_stream_eth_dhost(stream, mac); } else if( !strcmp(key, "smac") ) { if( parse_mac(value, mac) < 0 ) fprintf(stderr, "%s: ERROR: Failed to parse mac \"%s\"\n", __func__, key); return -EINVAL; rc = sc_stream_eth_shost(stream, mac); } else if( !strcmp(key, "vid") ) { rc = set_vlan_id(stream, value); } else if( !strcmp(key, "eth_type") ) { rc = set_eth_type(stream, value); } else if( !strcmp(key, "shost") ) { rc = sc_stream_ip_source_host(stream, value); } else if( !strcmp(key, "dhost") ) { rc = sc_stream_ip_dest_host(stream, value); } else if( !strcmp(key, "ip_protocol") ) { rc = set_protocol(stream, value); } else if( !strcmp(key, "sport") ) { rc = sc_stream_ip_source_port(stream, value); } else if( !strcmp(key, "dport") ) { rc = sc_stream_ip_dest_port(stream, value); } else { fprintf(stderr, "%s: ERROR: Unrecognised key \"%s\"\n", __func__, key); return -EINVAL; } } } return rc; }
int extra_comms(struct async *as, char **incexc, int *srestore, struct conf **confs, struct conf **cconfs) { struct vers vers; struct asfd *asfd; asfd=as->asfd; //char *restorepath=NULL; const char *peer_version=NULL; if(vers_init(&vers, cconfs)) goto error; if(vers.cli<vers.directory_tree) { set_int(confs[OPT_DIRECTORY_TREE], 0); set_int(cconfs[OPT_DIRECTORY_TREE], 0); } // Clients before 1.2.7 did not know how to do extra comms, so skip // this section for them. if(vers.cli<vers.min) return 0; if(asfd_read_expect(asfd, CMD_GEN, "extra_comms_begin")) { logp("problem reading in extra_comms\n"); goto error; } // Want to tell the clients the extra comms features that are // supported, so that new clients are more likely to work with old // servers. if(vers.cli==vers.feat_list) { // 1.3.0 did not support the feature list. if(asfd->write_str(asfd, CMD_GEN, "extra_comms_begin ok")) { logp("problem writing in extra_comms\n"); goto error; } } else { if(send_features(asfd, cconfs)) goto error; } if(extra_comms_read(as, &vers, srestore, incexc, confs, cconfs)) goto error; peer_version=get_string(cconfs[OPT_PEER_VERSION]); // This needs to come after extra_comms_read, as the client might // have set PROTO_1 or PROTO_2. switch(get_protocol(cconfs)) { case PROTO_AUTO: // The protocol has not been specified. Make a choice. if(vers.cli<vers.burp2) { // Client is burp-1.x.x, use protocol1. set_protocol(confs, PROTO_1); set_protocol(cconfs, PROTO_1); logp("Client is burp-%s - using protocol=%d\n", peer_version, PROTO_1); } else { // Client is burp-2.x.x, use protocol2. // This will probably never be reached because // the negotiation will take care of it. set_protocol(confs, PROTO_2); set_protocol(cconfs, PROTO_2); logp("Client is burp-%s - using protocol=%d\n", peer_version, PROTO_2); } break; case PROTO_1: // It is OK for the client to be burp1 and for the // server to be forced to protocol1. break; case PROTO_2: if(vers.cli>=vers.burp2) break; logp("protocol=%d is set server side, " "but client is burp version %s\n", peer_version); goto error; } if(get_protocol(cconfs)==PROTO_1) { if(get_e_rshash(cconfs[OPT_RSHASH])==RSHASH_UNSET) { set_e_rshash(confs[OPT_RSHASH], RSHASH_MD4); set_e_rshash(cconfs[OPT_RSHASH], RSHASH_MD4); } } return 0; error: return -1; }
static int extra_comms_read(struct async *as, struct vers *vers, int *srestore, char **incexc, struct conf **globalcs, struct conf **cconfs) { int ret=-1; struct asfd *asfd; struct iobuf *rbuf; asfd=as->asfd; rbuf=asfd->rbuf; while(1) { iobuf_free_content(rbuf); if(asfd->read(asfd)) goto end; if(rbuf->cmd!=CMD_GEN) { iobuf_log_unexpected(rbuf, __func__); goto end; } if(!strcmp(rbuf->buf, "extra_comms_end")) { if(asfd->write_str(asfd, CMD_GEN, "extra_comms_end ok")) goto end; break; } else if(!strncmp_w(rbuf->buf, "autoupgrade:")) { char *os=NULL; const char *autoupgrade_dir= get_string(globalcs[OPT_AUTOUPGRADE_DIR]); os=rbuf->buf+strlen("autoupgrade:"); iobuf_free_content(rbuf); if(os && *os && autoupgrade_server(as, vers->ser, vers->cli, os, get_cntr(globalcs), autoupgrade_dir)) goto end; } else if(!strcmp(rbuf->buf, "srestore ok")) { iobuf_free_content(rbuf); // Client can accept the restore. // Load the restore config, then send it. *srestore=1; if(conf_parse_incexcs_path(cconfs, get_string(cconfs[OPT_RESTORE_PATH])) || incexc_send_server_restore(asfd, cconfs)) goto end; // Do not unlink it here - wait until // the client says that it wants to do the // restore. // Also need to leave it around if the // restore is to an alternative client, so // that the code below that reloads the config // can read it again. //unlink(get_string(cconfs[OPT_RESTORE_PATH])); } else if(!strcmp(rbuf->buf, "srestore not ok")) { const char *restore_path=get_string( cconfs[OPT_RESTORE_PATH]); // Client will not accept the restore. unlink(restore_path); if(set_string(cconfs[OPT_RESTORE_PATH], NULL)) goto end; logp("Client not accepting server initiated restore.\n"); } else if(!strcmp(rbuf->buf, "sincexc ok")) { // Client can accept incexc conf from the // server. iobuf_free_content(rbuf); if(incexc_send_server(asfd, cconfs)) goto end; } else if(!strcmp(rbuf->buf, "incexc")) { // Client is telling server its incexc // configuration so that it can better decide // what to do on resume. iobuf_free_content(rbuf); if(incexc_recv_server(asfd, incexc, globalcs)) goto end; if(*incexc) { char *tmp=NULL; char comp[32]=""; snprintf(comp, sizeof(comp), "compression = %d\n", get_int(cconfs[OPT_COMPRESSION])); if(!(tmp=prepend(*incexc, comp))) goto end; free_w(incexc); *incexc=tmp; } } else if(!strcmp(rbuf->buf, "countersok")) { // Client can accept counters on // resume/verify/restore. logp("Client supports being sent counters.\n"); set_int(cconfs[OPT_SEND_CLIENT_CNTR], 1); } else if(!strncmp_w(rbuf->buf, "uname=") && strlen(rbuf->buf)>strlen("uname=")) { char *uname=rbuf->buf+strlen("uname="); if(!strncasecmp("Windows", uname, strlen("Windows"))) set_int(cconfs[OPT_CLIENT_IS_WINDOWS], 1); } else if(!strncmp_w(rbuf->buf, "orig_client=") && strlen(rbuf->buf)>strlen("orig_client=")) { if(conf_switch_to_orig_client(globalcs, cconfs, rbuf->buf+strlen("orig_client="))) goto end; // If this started out as a server-initiated // restore, need to load the restore file // again. if(*srestore) { if(conf_parse_incexcs_path(cconfs, get_string(cconfs[OPT_RESTORE_PATH]))) goto end; } if(asfd->write_str(asfd, CMD_GEN, "orig_client ok")) goto end; } else if(!strncmp_w(rbuf->buf, "restore_spool=")) { // Client supports temporary spool directory // for restores. if(set_string(cconfs[OPT_RESTORE_SPOOL], rbuf->buf+strlen("restore_spool="))) goto end; } else if(!strncmp_w(rbuf->buf, "protocol=")) { char msg[128]=""; // Client wants to set protocol. enum protocol protocol=get_protocol(cconfs); if(protocol!=PROTO_AUTO) { snprintf(msg, sizeof(msg), "Client is trying to use protocol=%s but server is set to protocol=%d\n", rbuf->buf, protocol); log_and_send_oom(asfd, __func__); goto end; } else if(!strcmp(rbuf->buf+strlen("protocol="), "1")) { set_protocol(cconfs, PROTO_1); set_protocol(globalcs, PROTO_1); } else if(!strcmp(rbuf->buf+strlen("protocol="), "2")) { set_protocol(cconfs, PROTO_2); set_protocol(globalcs, PROTO_2); } else { snprintf(msg, sizeof(msg), "Client is trying to use protocol=%s, which is unknown\n", rbuf->buf); log_and_send_oom(asfd, __func__); goto end; } logp("Client has set protocol=%d\n", (int)get_protocol(cconfs)); } else if(!strncmp_w(rbuf->buf, "rshash=blake2")) { #ifdef RS_DEFAULT_STRONG_LEN logp("Client is trying to use librsync hash blake2, but server does not support it.\n"); goto end; #else set_e_rshash(cconfs[OPT_RSHASH], RSHASH_BLAKE2); set_e_rshash(globalcs[OPT_RSHASH], RSHASH_BLAKE2); #endif } else if(!strncmp_w(rbuf->buf, "msg")) { set_int(cconfs[OPT_MESSAGE], 1); set_int(globalcs[OPT_MESSAGE], 1); } else { iobuf_log_unexpected(rbuf, __func__); goto end; } } ret=0; end: iobuf_free_content(rbuf); return ret; }
void SystemExpressionRepresentationTermProtocolMode::assign_value( ExpressionRepresentation *new_value ) { SystemExpressionRepresentationIntBoolean::assign_value( new_value ); set_protocol( exp_int ); }
static void run_test(int expected_ret, enum protocol protocol, int manio_entries, int blocks_per_file, void setup_asfds_callback(struct asfd *asfd, struct slist *slist)) { struct async *as; struct asfd *asfd; struct sdirs *sdirs; struct conf **confs; struct slist *slist=NULL; char *dir_for_notify=NULL; prng_init(0); base64_init(); hexmap_init(); setup(protocol, &as, &sdirs, &confs); set_string(confs[OPT_BACKUP], "1"); set_protocol(confs, protocol); asfd=asfd_mock_setup(&reads, &writes); as->asfd_add(as, asfd); as->read_write=async_rw_simple; as->read_quick=async_rw_simple; asfd->as=as; build_storage_dirs(sdirs, sd1, ARR_LEN(sd1)); if(manio_entries) { struct sbuf *s; if(protocol==PROTO_2) slist=build_manifest_with_data_files(sdirs->cmanifest, sdirs->data, manio_entries, blocks_per_file); else { slist=build_manifest(sdirs->cmanifest, protocol, manio_entries, 0 /*phase*/); for(s=slist->head; s; s=s->next) { char path[256]; if(!sbuf_is_filedata(s)) continue; snprintf(path, sizeof(path), "%s/%s%s", sdirs->currentdata, TREE_DIR, s->path.buf); build_file(path, "data"); } } } setup_asfds_callback(asfd, slist); fail_unless(do_restore_server( asfd, sdirs, ACTION_RESTORE, 0, // srestore &dir_for_notify, confs )==expected_ret); if(!expected_ret) { // FIX THIS: Should check for the presence and correctness of // changed and unchanged manios. } slist_free(&slist); free_w(&dir_for_notify); tear_down(&as, &asfd, &sdirs, &confs); }