uint16_t ipv6_csum(ipv6_hdr_t *ipv6_header, uint8_t *buf, uint16_t len, uint8_t proto) { uint16_t sum = 0; DEBUG("Calculate checksum over src: %s, dst: %s, len: %04X, buf: %p, proto: %u\n", ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN, &ipv6_header->srcaddr), ipv6_addr_to_str(addr_str, IPV6_MAX_ADDR_STR_LEN, &ipv6_header->destaddr), len, buf, proto); sum = len + proto; sum = csum(sum, (uint8_t *)&ipv6_header->srcaddr, 2 * sizeof(ipv6_addr_t)); sum = csum(sum, buf, len); return (sum == 0) ? 0xffff : HTONS(sum); }
void igmp_handler::set_ip_igmp_hdr(ip_igmp_tx_hdr_template_t* ip_igmp_hdr) { ip_igmp_hdr->m_ip_hdr.ihl = IPV4_IGMP_HDR_LEN_WORDS; ip_igmp_hdr->m_ip_hdr.tot_len = htons(IPV4_IGMP_HDR_LEN + sizeof(igmphdr)); ip_igmp_hdr->m_ip_hdr_ext = htonl(IGMP_IP_HEADER_EXT); ip_igmp_hdr->m_ip_hdr.check = 0; ip_igmp_hdr->m_ip_hdr.check = csum((unsigned short*)&ip_igmp_hdr->m_ip_hdr, (IPV4_IGMP_HDR_LEN_WORDS) * 2); // Create the IGMP header ip_igmp_hdr->m_igmp_hdr.type = IGMPV2_HOST_MEMBERSHIP_REPORT; ip_igmp_hdr->m_igmp_hdr.code = 0; ip_igmp_hdr->m_igmp_hdr.group = m_mc_addr.get_in_addr(); ip_igmp_hdr->m_igmp_hdr.csum = 0; ip_igmp_hdr->m_igmp_hdr.csum = csum((unsigned short*)&ip_igmp_hdr->m_igmp_hdr, IGMP_HDR_LEN_WORDS * 2); }
double cmean(double *vec, int tlen) { double tsum, tmean; tsum= csum(vec, tlen); tmean= tsum/(double) tlen; return(tmean); }
/* * The main procedure for processing the filtered packets */ bool process(char *packet, int pack_src) { ssize_t send_len; uint16_t size_ip, tot_len; struct iphdr *ip_header; struct udphdr *udp_header; ip_port_pair_mapping_t *test; ip_header = (struct iphdr*)packet; size_ip = ip_header->ihl<<2; tot_len = ntohs(ip_header->tot_len); udp_header = (struct udphdr*)((char *)ip_header + size_ip); test = get_test_pair(&(clt_settings.transfer), ip_header->saddr, udp_header->source); ip_header->daddr = test->target_ip; udp_header->dest = test->target_port; udpcsum(ip_header, udp_header); ip_header->check = 0; ip_header->check = csum((unsigned short *)ip_header, size_ip); send_len = send_ip_packet(ip_header, tot_len); if (-1 == send_len) { log_info(LOG_ERR, "send to back error,tot_len:%d", tot_len); return false; } return true; }
int main(int argc, char *argv[]) { double t = 0.0; struct sigaction sig; unsigned int k = 0; unsigned int iters = atoi(argv[1]); //Purposefully not validating input unsigned int bs = atoi(argv[2]); int sum; unsigned char *block = NULL; /* initialize RNG */ srand(time(NULL)); /* setup signals */ memset(&sig,0,sizeof(sig)); sig.sa_handler = signal_handler; sigaction (SIGINT, &sig, NULL); sigaction (SIGALRM, &sig, NULL); /* allocate and initialize data block */ block = (unsigned char*)malloc(sizeof(unsigned char) * bs); memset(block,rand()%256,sizeof(unsigned char)*bs); while (k < iters) { t = getTime(); sum = csum((unsigned short*)block, bs); t = getTime() - t; printf("%3.7f 0X%xd \n",t,sum); k++; } exit(0); }
bool tcp_write_checksum(uint8_t * tcp_segment, buffer_t * ip_psh) { struct tcphdr * tcp_header = (struct tcphdr *) tcp_segment; size_t size_ip = buffer_get_size(ip_psh), size_tcp = tcp_get_header_size(tcp_segment) + 2, // hardcoded payload size size_psh = size_ip + size_tcp; uint8_t * psh; // TCP checksum computation requires the IPv* header if (!ip_psh) { errno = EINVAL; return false; } // Allocate the buffer which will contains the pseudo header if (!(psh = calloc(1, size_psh))) { return false; } // Put the excerpt of the IP header into the pseudo header memcpy(psh, buffer_get_data(ip_psh), size_ip); // Put the TCP header and its content into the pseudo header memcpy(psh + size_ip, tcp_segment, size_tcp); // Overrides the TCP checksum in psh with zeros memset(psh + size_ip + offsetof(struct tcphdr, check), 0, sizeof(uint16_t)); // Compute the checksum tcp_header->check = csum((const uint16_t *) psh, size_psh); free(psh); return true; }
static void icmp6csum(struct in6_addr *src, struct in6_addr *dst, sendip_data *hdr, sendip_data *data) { icmp_header *icp = (icmp_header *)hdr->data; struct ipv6_pseudo_hdr phdr; /* Make sure tempbuf is word aligned */ u_int16_t *buf = malloc(sizeof(phdr)+hdr->alloc_len+data->alloc_len); u_int8_t *tempbuf = (u_int8_t *)buf; icp->check = 0; if(tempbuf == NULL) { fprintf(stderr,"Out of memory: ICMP checksum not computed\n"); return; } memcpy(tempbuf+sizeof(phdr), hdr->data, hdr->alloc_len); memcpy(tempbuf+sizeof(phdr)+hdr->alloc_len, data->data, data->alloc_len); /* do an ipv6 checksum */ memset(&phdr, 0, sizeof(phdr)); memcpy(&phdr.source, src, sizeof(struct in6_addr)); memcpy(&phdr.destination, dst, sizeof(struct in6_addr)); phdr.ulp_length = htonl(hdr->alloc_len+data->alloc_len); phdr.nexthdr = IPPROTO_ICMPV6; memcpy(tempbuf, &phdr, sizeof(phdr)); icp->check = csum(buf,sizeof(phdr)+hdr->alloc_len+data->alloc_len); free(buf); }
static inline uint16_t icmp_cksum(uint16_t l4_len, struct icmphdr const* icmp) { uint16_t cksum; cksum = csum((void*)icmp, l4_len); return cksum; }
static inline uint16_t ipv4_cksum(const struct iphdr *ipv4_hdr) { uint16_t cksum; cksum = csum((void*)ipv4_hdr, sizeof(struct iphdr)); return cksum; }
/* Make sure we get the calculation in RFC 1624 section 4 correct. */ static void test_rfc1624(void) { /* "...an IP packet header in which a 16-bit field m = 0x5555..." */ uint8_t data[32] = { 0xfe, 0x8f, 0xc1, 0x14, 0x4b, 0x6f, 0x70, 0x2a, 0x80, 0x29, 0x78, 0xc0, 0x58, 0x81, 0x77, 0xaa, 0x66, 0x64, 0xfc, 0x96, 0x63, 0x97, 0x64, 0xee, 0x12, 0x53, 0x1d, 0xa9, 0x2d, 0xa9, 0x55, 0x55 }; /* "...the one's complement sum of all other header octets is 0xCD7A." */ assert(ntohs(csum(data, sizeof data - 2)) == 0xffff - 0xcd7a); /* "...the header checksum would be: HC = ~(0xCD7A + 0x5555) = ~0x22D0 = 0xDD2F" */ assert(ntohs(csum(data, sizeof data)) == 0xdd2f); /* "a 16-bit field m = 0x5555 changes to m' = 0x3285..." */ data[30] = 0x32; data[31] = 0x85; /* "The new checksum via recomputation is: HC' = ~(0xCD7A + 0x3285) = ~0xFFFF = 0x0000" */ assert(ntohs(csum(data, sizeof data)) == 0x0000); /* "Applying [Eqn. 3] to the example above, we get the correct result: HC' = ~(C + (-m) + m') = ~(0x22D0 + ~0x5555 + 0x3285) = ~0xFFFF = 0x0000" */ assert(recalc_csum16(htons(0xdd2f), htons(0x5555), htons(0x3285)) == htons(0x0000)); mark('#'); }
int send_message(int socket, char* message) { int result; char* buffer = (char*)malloc((6+strlen(message)+1)*sizeof(char)); sprintf(buffer, "%04X%02X%s", (unsigned int)strlen(message), csum(message), message); result = send_string(socket, buffer); if (!(result == (int) strlen(message))) return -1; else return 0; }
/* Make sure we get the calculation in RFC 1624 section 4 correct. */ static void test_rfc1624(void) { /* "...an IP packet header in which a 16-bit field m = 0x5555..." */ uint8_t data[32] = "\xfe\x8f\xc1\x14\x4b\x6f\x70\x2a\x80\x29\x78\xc0\x58\x81\x77\xaa" "\x66\x64\xfc\x96\x63\x97\x64\xee\x12\x53\x1d\xa9\x2d\xa9\x55\x55"; /* "...the one's complement sum of all other header octets is 0xCD7A." */ assert(ntohs(csum(data, sizeof data - 2)) == 0xffff - 0xcd7a); /* "...the header checksum would be: HC = ~(0xCD7A + 0x5555) = ~0x22D0 = 0xDD2F" */ assert(ntohs(csum(data, sizeof data)) == 0xdd2f); /* "a 16-bit field m = 0x5555 changes to m' = 0x3285..." */ data[30] = 0x32; data[31] = 0x85; /* "The new checksum via recomputation is: HC' = ~(0xCD7A + 0x3285) = ~0xFFFF = 0x0000" */ assert(ntohs(csum(data, sizeof data)) == 0x0000); /* "Applying [Eqn. 3] to the example above, we get the correct result: HC' = ~(C + (-m) + m') = ~(0x22D0 + ~0x5555 + 0x3285) = ~0xFFFF = 0x0000" */ assert(recalc_csum16(htons(0xdd2f), htons(0x5555), htons(0x3285)) == htons(0x0000)); mark('#'); }
double w4(Point& atom){ const int l = 4; const int len = 2 * l + 1; Comp csum(0,0); for(int i=0; i<WN; i++){ Comp ctmp=WS[i]; for(int ii = 0; ii < 3; ii++){ ctmp *= atom.q4m[WI[i][ii] + 4]; } csum += ctmp; } return csum.real() / std::pow(atom.q4, 3) / std::pow(len / 4 / Pi, 1.5); }
static inline QString computeChecksum(const QString& s) { QByteArray ba = s.toUtf8(); QByteArray md5 = QCryptographicHash::hash(ba, QCryptographicHash::Md5); QString csum(""); for(int i = 0; i < md5.size(); i++) csum += QString("%1").arg((int)(md5[i]&0xFF), 2, 16, QLatin1Char('0')); return csum; }
/* * the main procedure for processing the filtered packets */ bool process(char *packet, int pack_src) { int diff; time_t cur_time; ssize_t send_len; uint16_t size_ip, tot_len; struct iphdr *ip_header; struct udphdr *udp_header; ip_port_pair_mapping_t *test; /* TODO time update will be optimized later */ cur_time = time(0); if (last_record_time != 0) { diff = cur_time - last_record_time; if (diff > 3) { log_info(LOG_INFO, "udp packets captured:%llu,packets sent:%llu", clt_udp_cnt, clt_udp_send_cnt); last_record_time = cur_time; } } else { last_record_time = cur_time; } ip_header = (struct iphdr *)packet; size_ip = ip_header->ihl<<2; tot_len = ntohs(ip_header->tot_len); udp_header = (struct udphdr*)((char *)ip_header + size_ip); test = get_test_pair(&(clt_settings.transfer), ip_header->daddr, udp_header->dest); ip_header->daddr = test->target_ip; udp_header->dest = test->target_port; udpcsum(ip_header, udp_header); ip_header->check = 0; ip_header->check = csum((unsigned short *)ip_header, size_ip); /* check if it needs fragmentation */ if (tot_len > clt_settings.mtu) { ip_fragmentation(ip_header, udp_header); } else { send_len = send_ip_packet(ip_header, tot_len); if (-1 == send_len) { log_info(LOG_ERR, "send to back error,tot_len:%d", tot_len); return false; } clt_udp_send_cnt++; } return true; }
void srf_write(FILE * const ofP, struct srf * const srfP) { uint8_t srfCsum; /* checksum value in SRF image */ size_t padLen; unsigned int i; size_t bytesWritten; padLen = 1; /* initial value */ if (!checkHeader(&srfP->header)) pm_error("invalid srf header"); if (!writeHeader(ofP, &srfP->header)) pm_error("write srf header"); padLen += lenHeader(&srfP->header); for (i = 0; i < srfP->header.img_cnt; ++i) { if (!writeImg(ofP, i, &srfP->imgs[i])) pm_error("invalid srf image %u", i); padLen += lenImg(&srfP->imgs[i]); } /* Pad to 256 bytes */ padLen = 256 - (padLen % 256); if (padLen) { char * d; size_t bytesWritten; MALLOCARRAY(d, padLen); if (!d) pm_error("Could not allocate memory for %u bytes of padding", (unsigned)padLen); memset(d, 0xff, padLen); bytesWritten = fwrite(d, 1, padLen, ofP); if (bytesWritten != padLen) pm_error("unable to 0xff pad file"); free(d); } /* Write out checksum byte */ srfCsum = 0xff - csum(srfP, padLen) + 1; bytesWritten = fwrite(&srfCsum, 1, 1, ofP); if (bytesWritten != 1) pm_error("unable to write checksum"); }
static void icmpcsum(sendip_data *icmp_hdr, sendip_data *data) { icmp_header *icp = (icmp_header *)icmp_hdr->data; u_int16_t *buf = malloc(icmp_hdr->alloc_len+data->alloc_len); u_int8_t *tempbuf = (u_int8_t *)buf; icp->check = 0; if(tempbuf == NULL) { fprintf(stderr,"Out of memory: ICMP checksum not computed\n"); return; } memcpy(tempbuf,icmp_hdr->data,icmp_hdr->alloc_len); memcpy(tempbuf+icmp_hdr->alloc_len,data->data,data->alloc_len); icp->check = csum(buf,icmp_hdr->alloc_len+data->alloc_len); free(buf); }
bool icmpv4_write_checksum(uint8_t * icmpv4_segment, buffer_t * ipv4_psh) { struct icmphdr * icmpv4_header = (struct icmphdr *) icmpv4_segment; // No pseudo header not required in ICMPv4 if (ipv4_psh) { errno = EINVAL; return false; } // The ICMPv4 checksum must be set to 0 before its calculation icmpv4_header->checksum = 0; icmpv4_header->checksum = csum((uint16_t *) icmpv4_segment, sizeof(struct icmphdr)); return true; }
void eeprom_save(void) { struct eeprom_data e; e.main_pwm[0] = main_pwm[0]; e.main_pwm[1] = main_pwm[1]; e.main_pwm[2] = main_pwm[2]; e.usart_pwm = usart_pwm; uint8_t wcsum = csum( (void *)&e, sizeof(e) ); EEPROM_write_block( 1, (void *)&e, sizeof(e) ); EEPROM_write( 0, wcsum ); }
static int udp_error(struct sk_buff *skb, unsigned int dataoff, enum ip_conntrack_info *ctinfo, int pf, unsigned int hooknum, int (*csum)(const struct sk_buff *, unsigned int)) { unsigned int udplen = skb->len - dataoff; struct udphdr _hdr, *hdr; /* Header is too small? */ hdr = skb_header_pointer(skb, dataoff, sizeof(_hdr), &_hdr); if (hdr == NULL) { if (LOG_INVALID(IPPROTO_UDP)) nf_log_packet(pf, 0, skb, NULL, NULL, NULL, "nf_ct_udp: short packet "); return -NF_ACCEPT; } /* Truncated/malformed packets */ if (ntohs(hdr->len) > udplen || ntohs(hdr->len) < sizeof(*hdr)) { if (LOG_INVALID(IPPROTO_UDP)) nf_log_packet(pf, 0, skb, NULL, NULL, NULL, "nf_ct_udp: truncated/malformed packet "); return -NF_ACCEPT; } /* Packet with no checksum */ if (!hdr->check) return NF_ACCEPT; /* Checksum invalid? Ignore. * We skip checking packets on the outgoing path * because the semantic of CHECKSUM_HW is different there * and moreover root might send raw packets. * FIXME: Source route IP option packets --RR */ if (((pf == PF_INET && hooknum == NF_IP_PRE_ROUTING) || (pf == PF_INET6 && hooknum == NF_IP6_PRE_ROUTING)) && skb->ip_summed != CHECKSUM_UNNECESSARY && csum(skb, dataoff)) { if (LOG_INVALID(IPPROTO_UDP)) nf_log_packet(pf, 0, skb, NULL, NULL, NULL, "nf_ct_udp: bad UDP checksum "); return -NF_ACCEPT; } return NF_ACCEPT; }
void eeprom_load(void) { struct eeprom_data e; EEPROM_read_block( 1, (void *)&e, sizeof(e) ); uint8_t rcsum = EEPROM_read( 0 ); uint8_t ccsum = csum( (void *)&e, sizeof(e) ); if( rcsum != ccsum ) return; main_pwm[0] = e.main_pwm[0]; main_pwm[1] = e.main_pwm[1]; main_pwm[2] = e.main_pwm[2]; usart_pwm = e.usart_pwm; }
void srf_read(FILE * const ifP, bool const verbose, struct srf * const srfP) { uint8_t trialCsum; size_t padLen; unsigned char pad[256]; unsigned int i; if (!readHeader(ifP, &srfP->header)) pm_error("short srf header"); if (!checkHeader(&srfP->header)) pm_error("invalid srf header"); if (verbose) pm_message("reading srf ver %s with prod code %s and %u images", srfP->header.ver.val, srfP->header.prod.val, srfP->header.img_cnt); MALLOCARRAY(srfP->imgs, srfP->header.img_cnt); if (!srfP->imgs) pm_error("Could not allocate memory for %u images", srfP->header.img_cnt); for (i = 0; i < srfP->header.img_cnt; ++i) if (!readImg(ifP, verbose, i, &srfP->imgs[i])) pm_error("invalid srf image %u", i); padLen = fread(pad, 1, sizeof(pad), ifP); if (!feof(ifP)) { pm_errormsg("excess data at end of file"); return; } trialCsum = csum(srfP, 0); /* initial value */ for (i = 0; i < padLen; ++i) trialCsum += pad[i]; if (trialCsum != 0) pm_errormsg("checksum does not match"); }
static f_pixel averagepixels( uint clrs, const hist_item achv[], double min_opaque_val ) { f_pixel csum(0,0,0,0); double sum = 0.0; double maxa = 0.0; for (uint i=0; i<clrs; ++i) { double weight = 1.0; const hist_item& hist = achv[i]; const f_pixel px = hist.acolor; /* give more weight to colors that are further away from average this is intended to prevent desaturation of images and fading of whites */ f_pixel tmp = f_pixel(0.5, 0.5, 0.5, 0.5) - px; tmp.square(); weight += tmp.r + tmp.g + tmp.b; weight *= hist.adjusted_weight; sum += weight; csum += px * weight; /* find if there are opaque colors, in case we're supposed to preserve opacity exactly (ie_bug) */ maxa = max(maxa, px.alpha); } /* Colors are in premultiplied alpha colorspace, so they'll blend OK even if different opacities were mixed together */ if (!sum) sum = 1.0; csum /= sum; assert(!isnan(csum.r) && !isnan(csum.g) && !isnan(csum.b) && !isnan(csum.alpha)); /** if there was at least one completely opaque color, "round" final color to opaque */ if (csum.alpha >= min_opaque_val && maxa >= (255.0/256.0)) csum.alpha = 1.0; return csum; }
//int Connect(e){ // return sockfd int Connect(char* tgt_ip_addr, int portNum){ destPort = portNum; srand((unsigned)time(NULL)); srcPort = 1000 + rand()%63535; sock2send = createRaw(IPPROTO_RAW); sock2recv = createRaw(IPPROTO_TCP); char **pptr = NULL; unsigned int OPTION_SIZE = 20; memset(datagram,0,4096); iph = (struct iphdr *) datagram; tcph = (struct TCP_header *) (datagram + sizeof(struct ip)); struct hostent *host = NULL; buf = malloc(1024); send_addr.sin_family = AF_INET; send_addr.sin_port = htons(destPort); send_addr.sin_addr.s_addr = inet_addr(tgt_ip_addr); look_for_local_ip(srcaddr); printf("Local IP Address:\t%s\n",srcaddr); // ip headG iph->ihl = 5; iph->version = 4; iph->tos = 0; iph->tot_len = sizeof(struct iphdr) + sizeof(struct TCP_header); iph->id = htonl(54321); iph->frag_off = 0; iph->ttl = 60; iph->protocol = IPPROTO_TCP; iph->check = 0; iph->saddr = inet_addr(srcaddr); iph->daddr = send_addr.sin_addr.s_addr; iph->check = csum((unsigned short*)datagram, iph->tot_len); three_hand_shake(sock2send,sock2recv,datagram,send_addr); return sock2recv; }
int UdpSocket::s_send(char* data,int size,in_addr_t srcip,int srcport,in_addr_t dstip,int dstport) { int ret=0; int allsize=sizeof(struct udphdr)+size; char* datagram=new char[allsize]; struct udphdr *udph; memset(datagram, 0, allsize); memcpy(datagram + sizeof(struct udphdr),data,size); udph = (struct udphdr *)(datagram); udph->source = htons(srcport); udph->dest = htons(dstport); udph->len = htons(sizeof(struct udphdr) + size); udph->check = 0; struct pseudo_header psh; psh.source_address = srcip; psh.dest_address = dstip; psh.placeholder = 0; psh.protocol = IPPROTO_UDP; psh.length = htons(allsize); int psize=sizeof(struct pseudo_header)+allsize; char* pseudogram = (char*)malloc(psize); memcpy(pseudogram , (char*) &psh , sizeof(struct pseudo_header)); memcpy(pseudogram + sizeof(struct pseudo_header) , udph , allsize); udph->check = csum((unsigned short*) pseudogram ,psize); printf("SEND_UDP (%d):\n",allsize); for(const char* p = datagram; p<(datagram+allsize); ++p) { printf("%02X ", (char)*p); } printf("\n"); ret=IpSocket::s_send(datagram,allsize,TYPE_UDP,srcip,dstip); delete[] datagram; return ret; }
int recv_message(int socket, char** buffer) { char size[6]; // we allow 4 hex bytes for size; this allows messages to be at // most 65536 bytes in length int res, length, sum; res = recv_string(socket,size,5); if (res!=6) { printf("only recv'd %d hex digits\n", res); return -1; } res = htoi(size, &sum); // parse the hex digits if (!(res==6)) { printf("only parsed %d hex digits in \"%s\"\n", res, size); return -1; } // now, noting that a hex digit is 4 bits, we can use bit ops instead of // string ones: length = sum >> 8; // drop the two characters off the right hand side sum = sum - (length << 8); // leave only the last two in sum *buffer = (char*) malloc((length+2)*sizeof(char)); res = recv_string(socket, *buffer, length); if (!(length == res)) { printf("message had length %d, but said it was %d\n", res, length); return -1; } if (!((res = csum(*buffer)) == sum)) { printf("\"%s\" had checksum %x, but said it was %x\n", *buffer, res, sum); return -1; } return length; }
static void ipcsum(sendip_data *ip_hdr) { ip_header *ip = (ip_header *)ip_hdr->data; ip->check=0; ip->check=csum((u_int16_t *)ip_hdr->data, ip_hdr->alloc_len); }
int main(void) { const struct test_case *tc; int i; for (tc = test_cases; tc < &test_cases[ARRAY_SIZE(test_cases)]; tc++) { const uint16_t *data16 = (const uint16_t *) tc->data; const uint32_t *data32 = (const uint32_t *) tc->data; uint32_t partial; size_t i; /* Test csum(). */ assert(ntohs(csum(tc->data, tc->size)) == tc->csum); mark('.'); /* Test csum_add16(). */ partial = 0; for (i = 0; i < tc->size / 2; i++) { partial = csum_add16(partial, data16[i]); } assert(ntohs(csum_finish(partial)) == tc->csum); mark('.'); /* Test csum_add32(). */ partial = 0; for (i = 0; i < tc->size / 4; i++) { partial = csum_add32(partial, data32[i]); } assert(ntohs(csum_finish(partial)) == tc->csum); mark('.'); /* Test alternating csum_add16() and csum_add32(). */ partial = 0; for (i = 0; i < tc->size / 4; i++) { if (i % 2) { partial = csum_add32(partial, data32[i]); } else { partial = csum_add16(partial, data16[i * 2]); partial = csum_add16(partial, data16[i * 2 + 1]); } } assert(ntohs(csum_finish(partial)) == tc->csum); mark('.'); /* Test csum_continue(). */ partial = 0; for (i = 0; i < tc->size / 4; i++) { if (i) { partial = csum_continue(partial, &data32[i], 4); } else { partial = csum_continue(partial, &data16[i * 2], 2); partial = csum_continue(partial, &data16[i * 2 + 1], 2); } } assert(ntohs(csum_finish(partial)) == tc->csum); mark('#'); } test_rfc1624(); /* Test recalc_csum16(). */ for (i = 0; i < 32; i++) { uint16_t old_u16, new_u16; uint16_t old_csum; uint16_t data[16]; int j, index; for (j = 0; j < ARRAY_SIZE(data); j++) { data[j] = random_uint32(); } old_csum = csum(data, sizeof data); index = random_range(ARRAY_SIZE(data)); old_u16 = data[index]; new_u16 = data[index] = random_uint32(); assert(csum(data, sizeof data) == recalc_csum16(old_csum, old_u16, new_u16)); mark('.'); } mark('#'); /* Test recalc_csum32(). */ for (i = 0; i < 32; i++) { uint32_t old_u32, new_u32; uint16_t old_csum; uint32_t data[16]; int j, index; for (j = 0; j < ARRAY_SIZE(data); j++) { data[j] = random_uint32(); } old_csum = csum(data, sizeof data); index = random_range(ARRAY_SIZE(data)); old_u32 = data[index]; new_u32 = data[index] = random_uint32(); assert(csum(data, sizeof data) == recalc_csum32(old_csum, old_u32, new_u32)); mark('.'); } mark('#'); putchar('\n'); return 0; }
/* Puts into 'b' a packet that flow_extract() would parse as having the given * 'flow'. * * (This is useful only for testing, obviously, and the packet isn't really * valid. It hasn't got some checksums filled in, for one, and lots of fields * are just zeroed.) */ void flow_compose(struct ofpbuf *b, const struct flow *flow) { eth_compose(b, flow->dl_dst, flow->dl_src, ntohs(flow->dl_type), 0); if (flow->dl_type == htons(FLOW_DL_TYPE_NONE)) { struct eth_header *eth = b->l2; eth->eth_type = htons(b->size); return; } if (flow->vlan_tci & htons(VLAN_CFI)) { eth_push_vlan(b, flow->vlan_tci); } if (flow->dl_type == htons(ETH_TYPE_IP)) { struct ip_header *ip; b->l3 = ip = ofpbuf_put_zeros(b, sizeof *ip); ip->ip_ihl_ver = IP_IHL_VER(5, 4); ip->ip_tos = flow->nw_tos; ip->ip_ttl = flow->nw_ttl; ip->ip_proto = flow->nw_proto; put_16aligned_be32(&ip->ip_src, flow->nw_src); put_16aligned_be32(&ip->ip_dst, flow->nw_dst); if (flow->nw_frag & FLOW_NW_FRAG_ANY) { ip->ip_frag_off |= htons(IP_MORE_FRAGMENTS); if (flow->nw_frag & FLOW_NW_FRAG_LATER) { ip->ip_frag_off |= htons(100); } } if (!(flow->nw_frag & FLOW_NW_FRAG_ANY) || !(flow->nw_frag & FLOW_NW_FRAG_LATER)) { if (flow->nw_proto == IPPROTO_TCP) { struct tcp_header *tcp; b->l4 = tcp = ofpbuf_put_zeros(b, sizeof *tcp); tcp->tcp_src = flow->tp_src; tcp->tcp_dst = flow->tp_dst; tcp->tcp_ctl = TCP_CTL(0, 5); } else if (flow->nw_proto == IPPROTO_UDP) { struct udp_header *udp; b->l4 = udp = ofpbuf_put_zeros(b, sizeof *udp); udp->udp_src = flow->tp_src; udp->udp_dst = flow->tp_dst; } else if (flow->nw_proto == IPPROTO_SCTP) { struct sctp_header *sctp; b->l4 = sctp = ofpbuf_put_zeros(b, sizeof *sctp); sctp->sctp_src = flow->tp_src; sctp->sctp_dst = flow->tp_dst; } else if (flow->nw_proto == IPPROTO_ICMP) { struct icmp_header *icmp; b->l4 = icmp = ofpbuf_put_zeros(b, sizeof *icmp); icmp->icmp_type = ntohs(flow->tp_src); icmp->icmp_code = ntohs(flow->tp_dst); icmp->icmp_csum = csum(icmp, ICMP_HEADER_LEN); } } ip = b->l3; ip->ip_tot_len = htons((uint8_t *) b->data + b->size - (uint8_t *) b->l3); ip->ip_csum = csum(ip, sizeof *ip); } else if (flow->dl_type == htons(ETH_TYPE_IPV6)) { /* XXX */ } else if (flow->dl_type == htons(ETH_TYPE_ARP) || flow->dl_type == htons(ETH_TYPE_RARP)) { struct arp_eth_header *arp; b->l3 = arp = ofpbuf_put_zeros(b, sizeof *arp); arp->ar_hrd = htons(1); arp->ar_pro = htons(ETH_TYPE_IP); arp->ar_hln = ETH_ADDR_LEN; arp->ar_pln = 4; arp->ar_op = htons(flow->nw_proto); if (flow->nw_proto == ARP_OP_REQUEST || flow->nw_proto == ARP_OP_REPLY) { put_16aligned_be32(&arp->ar_spa, flow->nw_src); put_16aligned_be32(&arp->ar_tpa, flow->nw_dst); memcpy(arp->ar_sha, flow->arp_sha, ETH_ADDR_LEN); memcpy(arp->ar_tha, flow->arp_tha, ETH_ADDR_LEN); } } if (eth_type_mpls(flow->dl_type)) { b->l2_5 = b->l3; push_mpls(b, flow->dl_type, flow->mpls_lse); } }
void solve() { struct poly *d; float i=0,u=0 ,a,tm=0 ; float sum=0,sud=0,t=0,c=1,pr; int choice ; printf("Select your choice for calculation :\n") ; printf("1.Automatic :\n"); printf("2.Manually :"); scanf("%d",&choice); switch(choice) { case 1: for(i=0;;i=i+c) { // temp=start; // sum = 0; sum = csum(i,start) ; printf("\nfor x=%.0f SUM is:%.4f",i,sum) ; if(sum<0) { if(sum<t) { c=1; } if(t>0) { break;} } else if(sum>0) { if(sum>t) { c=-1; } if(t<0) { break;} } else { break ;} if(i<-300||i>300) { printf("\n\n!!!!Out of range!!!!") ; exit(0); } t=sum ; } if(sum==0) { printf("\n\nRoot is :%.0f",i); goto tag; } else{ if(u<i) { u=i; i=i+c; } else { u=i+c; } } break; case 2: printf("\nEnter the range :\n"); printf("Enter the limit 1:"); scanf("%f",&u); printf("Enter the limit 2:"); scanf("%f",&i); if(u<i) { c=u; u=i; i=c; } } printf("\n\nRange %.0f",i); printf("<->%.0f\n",u) ; c=i+u; c=c/2; temp = start; d = diff(temp); printf("\nf'(x) :"); display(d) ; do { tm++; pr = c; sum=csum(c,start); sud=csum(c,d); c = c - (sum/sud); //if((c-pr))0.0001) // {break;} }while((pr-c)>0.0001||(pr-c)<-0.0001); printf("\n\nRoot is:%f",c) ; tag: } float csum(float i,struct poly *temp) { float sum=0,a=0,po=0; for(;temp!=NULL;) { if(((i==0)||(temp->co==0))&&(temp->power!=0)) { a=0; } else { if(temp->power==0) {po=1; a = (temp->co)*po; sum = sum + a ; break; } else {po = pow(i,(temp->power)) ;} a = (temp->co)*po; } sum = sum + a ; temp=temp->link; // printf("\n%f",a) ; // printf("\n%f",po) ; } return sum; }