static int c2w( int c_count, const char* c, int w_count, wchar_t* w // array of at least w_count+1 wide characters ) { // convert UTF-8 string to UTF-16 string int rc = 0; if ( w ) w[0] = 0; // returns length of converted c[] if ( w_count > 0 && w && c_count > 0 && c && c[0] ) { w[0] = 0; if ( c ) { unsigned int error_status = 0; unsigned int error_mask = 0xFFFFFFFF; ON__UINT32 error_code_point = 0xFFFD; const char* p1 = 0; rc = ON_ConvertUTF8ToWideChar(c,c_count,w,w_count,&error_status,error_mask,error_code_point,&p1); if ( rc > 0 && rc <= w_count ) w[rc] = 0; else { w[w_count] = 0; rc = 0; } if ( 0 != error_status ) { ON_ERROR("Error converting UTF-8 encoded char string to UTF-16 encoded wchar_t string."); } } } return rc; }
bool ON_GetKnotVectorSpanVector( int order, // order (>=2) int cv_count, // cv count const double* knot, // knot[] array double* s // s[] array ) { if ( 0 == knot || 0 == s ) { if ( 0 != order || 0 != cv_count ) { ON_ERROR("NULL knot[] or s[] passed to ON_KnotVectorSpanCount."); return false; } return true; } int i, span_count = 0; s[span_count++] = knot[order-2]; for ( i = order-1; i < cv_count; i++ ) { if ( knot[i] > knot[i-1] ) s[span_count++] = knot[i]; } return (span_count>1) ? true : false; }
void ON_wString::Empty() { ON_wStringHeader* p = Header(); if ( p != pEmptyStringHeader ) { if ( p->ref_count > 1 ) { // string memory is shared p->ref_count--; Create(); } else if ( p->ref_count == 1 ) { // string memory is not shared - reuse it if (m_s && p->string_capacity>0) *m_s = 0; p->string_length = 0; } else { // should not happen ON_ERROR("ON_wString::Empty() encountered invalid header - fixed."); Create(); } } else { // initialized again Create(); } }
bool ON_BezierCage::IsSingular( // true if surface side is collapsed to a point int side // side of parameter space to test // 0 = south, 1 = east, 2 = north, 3 = west, 4 = bottom, 5 =top ) const { ON_ERROR("TODO: fill in ON_BezierCage::IsSingular\n"); return false; /* int i,j,k=0; ON_3dPoint p[2]; double fuzz[2] = {0.0,0.0}; p[0].Zero(); p[1].Zero(); int i0 = 0; int i1 = 0; int j0 = 0; int j1 = 0; switch ( side ) { case 0: // south i0 = 0; i1 = Order(0); j0 = 0; j1 = 1; break; case 1: // east i0 = Order(0)-1; i1 = Order(0); j0 = 0; j1 = Order(1); break; case 2: // north i0 = 0; i1 = Order(0); j0 = Order(1)-1; j1 = Order(1); break; case 3: // west i0 = 0; i1 = 1; j0 = 0; j1 = Order(1); break; default: return false; break; } GetCV(i0,j0,p[k]); fuzz[k] = p[k].Fuzz(); for ( i = i0; i < i1; i++ ) for ( j = j0; j < j1; j++ ) { k = (k+1)%2; GetCV( i, j, p[k] ); fuzz[k] = p[k].Fuzz(); if ( (p[0]-p[1]).MaximumCoordinate() > fuzz[0]+fuzz[1] ) return false; } return true; */ }
bool ON_BezierCage::IsSingular( // true if surface side is collapsed to a point int side // side of parameter space to test // 0 = south, 1 = east, 2 = north, 3 = west, 4 = bottom, 5 =top ) const { ON_ERROR("TODO: fill in ON_BezierCage::IsSingular\n"); return false; }
static void daemon_init(void) { fd = open("./ettercap_demonized.log", O_CREAT|O_TRUNC|O_WRONLY, 0600); ON_ERROR(fd, -1, "Can't open daemon log file"); /* daemonize ettercap */ daemonize(); }
bool ON_SubDArchiveIdMap::AddComponentPtr(ON_SubDComponentPtr eptr, unsigned int archive_id) { if (m_element_count != archive_id) { ON_ERROR("Archive id is not valid and ON_SubD::Read will fail."); return false; } ON_SubDComponentPtr* p = (ON_SubDComponentPtr*)m_fsp.AllocateElement(); *p = eptr; #if defined(ON_DEBUG) if (0 != archive_id) { const ON_SubDComponentPtr* p1 = (const ON_SubDComponentPtr*)m_fsp.Element(archive_id); unsigned int archive_id1 = 0; if (p1 == p) { switch (p1->ComponentType()) { case ON_SubDComponentPtr::Type::Vertex: archive_id1 = p1->Vertex()->ArchiveId(); break; case ON_SubDComponentPtr::Type::Edge: archive_id1 = p1->Edge()->ArchiveId(); break; case ON_SubDComponentPtr::Type::Face: archive_id1 = p1->Face()->ArchiveId(); break; default: ON_ERROR("invalid element type"); break; } } if (archive_id1 != archive_id) { // break here and then see what went wrong ON_SubDIncrementErrorCount(); m_fsp.Element(archive_id); m_fsp.Element(archive_id); } } #endif m_element_count++; return true; }
// // Object creation // void* check_malloc(size_t size) { void* result = malloc(size); if(result == NULL) ON_ERROR(-1); return result; }
char* ON_UuidToString( const ON_UUID& uuid, char* s) { // s - [out] The s[] char array must have length >= 37. // The returned char array will have a 36 // character uuid in s[0..35] and a null in s[36]. // NOTE WELL: // This code has to work on non-Windows OSs and on both big and // little endian CPUs. The result must satisfy // uuid == ON_UuidFromString(ON_UuidToString(uuid,s)) // 31 August 2005 Dale Lear // Changed upper case to lower case so result is // identical to the string returned by Windows' ::UuidToString(). //static const char x[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; static const char x[16] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'}; static const int addhyphen[16] = {0,0,0,1, 0,1, 0,1, 0,1, 0, 0, 0, 0, 0, 0}; const unsigned char* b = (const unsigned char*)&uuid; char* p; int i; static const int* rho = ( ON::big_endian == ON::Endian() ) ? big_endian_rho : little_endian_rho; // 5 December 2002 Dale Lear: // There is either a bug in Purify (likely) or perhaps a bug in the // way Microsoft compiles c>>4 when c is an unsigned char. In any // case, changing c to an unsigned int makes purify happy and should // work just as well. // //unsigned char c; unsigned int c; if ( !s ) return 0; p = s; for ( i = 0; i < 16; i++ ) { c = b[rho[i]]; *p++ = x[c>>4]; // purify gripes here if c is an unsigned char - the code runs fine. *p++ = x[c&0x0F]; if ( addhyphen[i] ) *p++ = '-'; } *p = 0; #if defined(ON_DEBUG) { ON_UUID u = ON_UuidFromString(s); if ( ON_UuidCompare(&u,&uuid) ) { ON_ERROR("ON_UuidToString() bug"); // <- breakpoint here } } #endif return s; }
ON_BOOL32 ON_Light::IsValid( ON_TextLog* text_log ) const { int s = Style(); if ( s <= ON::unknown_light_style || s >= ON::light_style_count ) { ON_ERROR("ON_Light::IsValid(): illegal light style."); return false; } return true; }
void log_write_packet(struct log_fd *fd, struct packet_object *po) { struct log_header_packet hp; int c, zerr; memset(&hp, 0, sizeof(struct log_header_packet)); /* adjust the timestamp */ memcpy(&hp.tv, &po->ts, sizeof(struct timeval)); hp.tv.tv_sec = htonl(hp.tv.tv_sec); hp.tv.tv_usec = htonl(hp.tv.tv_usec); memcpy(&hp.L2_src, &po->L2.src, MEDIA_ADDR_LEN); memcpy(&hp.L2_dst, &po->L2.dst, MEDIA_ADDR_LEN); memcpy(&hp.L3_src, &po->L3.src, sizeof(struct ip_addr)); memcpy(&hp.L3_dst, &po->L3.dst, sizeof(struct ip_addr)); hp.L4_flags = po->L4.flags; hp.L4_proto = po->L4.proto; hp.L4_src = po->L4.src; hp.L4_dst = po->L4.dst; /* the length of the payload */ hp.len = htonl(po->DATA.disp_len); LOG_LOCK; if (fd->type == LOG_COMPRESSED) { c = gzwrite(fd->cfd, &hp, sizeof(hp)); ON_ERROR(c, -1, "%s", gzerror(fd->cfd, &zerr)); c = gzwrite(fd->cfd, po->DATA.disp_data, po->DATA.disp_len); ON_ERROR(c, -1, "%s", gzerror(fd->cfd, &zerr)); } else { c = write(fd->fd, &hp, sizeof(hp)); ON_ERROR(c, -1, "Can't write to logfile"); c = write(fd->fd, po->DATA.disp_data, po->DATA.disp_len); ON_ERROR(c, -1, "Can't write to logfile"); } LOG_UNLOCK; }
bool ON_SubDArchiveIdMap::ConvertArchiveIdToRuntimeVertexPtr( unsigned int vertex_count, size_t vertex_capacity, ON_SubDVertex** vertex ) { if ( 0 == vertex_count ) return true; if ( 0 == vertex_capacity || nullptr == vertex ) return ON_SUBD_RETURN_ERROR(false); if ( vertex_count > vertex_capacity ) return ON_SUBD_RETURN_ERROR(false); for (unsigned int i = 0; i < vertex_count; i++) { ON__UINT_PTR vptr = (ON__UINT_PTR)(vertex[i]); vertex[i] = nullptr; const unsigned int archive_id = ON_SubDArchiveIdMap::ArchiveIdFromComponentPtr(vptr); // future use // ON__UINT_PTR flags = ON_SUBD_ELEMENT_FLAGS(vptr); if (0 == archive_id || archive_id < m_archive_id_partition[0] || archive_id >= m_archive_id_partition[1]) { ON_ERROR("Invalid vertex archive id."); continue; } const ON_SubDComponentPtr* eleptr = ComponentPtrFromArchiveId(archive_id); if (nullptr == eleptr) { ON_ERROR("null element pointer."); continue; } ON_SubDVertex* v = eleptr->Vertex(); if (nullptr == v) { ON_ERROR("null vertex pointer."); continue; } if (archive_id != v->ArchiveId()) { ON_ERROR("archive_id != v->ArchiveId()."); continue; } vertex[i] = v; } return true; }
int write_output(void) { int fd; struct filter_op *fop; struct filter_header fh; size_t ninst, i, data_len; u_char pad = 0, *data = NULL; /* conver the tree to an array of filter_op */ ninst = compile_tree(&fop); if (fop == NULL) return -E_NOTHANDLED; if (ninst == 0) return -E_INVALID; /* create the file */ fd = open(GBL_OPTIONS->output_file, O_CREAT | O_RDWR | O_TRUNC | O_BINARY, 0644); ON_ERROR(fd, -1, "Can't create file %s", GBL_OPTIONS->output_file); /* display the message */ fprintf(stdout, " Writing output to \'%s\' ", GBL_OPTIONS->output_file); fflush(stdout); /* compute the header */ fh.magic = htons(EC_FILTER_MAGIC); strncpy(fh.version, EC_VERSION, sizeof(fh.version)); fh.data = sizeof(fh); data_len = create_data_segment(&data, &fh, fop, ninst); /* write the header */ write(fd, &fh, sizeof(struct filter_header)); /* write the data segment */ write(fd, data, data_len); /* write padding to next 8-byte boundary */ for (i = 0; i < fh.code - (fh.data + data_len); i++) write(fd, &pad, 1); /* write the instructions */ for (i = 0; i < ninst; i++) { print_progress_bar(&fop[i]); write(fd, &fop[i], sizeof(struct filter_op)); } close(fd); fprintf(stdout, " done.\n\n"); fprintf(stdout, " -> Script encoded into %d instructions.\n\n", (int)(i - 1)); return E_SUCCESS; }
void open_log(char *file) { int zerr; GBL_LOGFILE = strdup(file); GBL_LOG_FD = gzopen(file, "rb"); ON_ERROR(GBL_LOG_FD, NULL, "%s", gzerror(GBL_LOG_FD, &zerr)); }
unsigned int ON_3dmObjectAttributes::ApplyParentalControl( const ON_3dmObjectAttributes& parents_attributes, unsigned int control_limits ) { ON_ERROR("Do not use deprecated version of ON_3dmObjectAttributes::ApplyParentalControl()"); ON_Layer bogus_layer; bogus_layer.m_layer_index = -1; return ApplyParentalControl(parents_attributes,bogus_layer,control_limits); }
void ON_FLT_SNAN( float* x) { union { float x; unsigned char b[4]; } u; #if defined(ON_LITTLE_ENDIAN) #define i3 3 #define i2 2 #elif defined(ON_BIG_ENDIAN) #define i3 0 #define i2 1 #else unsigned int i3, i2; u.x = 2.0f; // sign = 0; mantissa = 0; exponent = 1000 0000 if ( 0x40 == u.b[3] && 0 == u.b[0] && 0 == u.b[1] && 0 == u.b[2] ) { // little endian doubles i3 = 3; i2 = 2; } else if ( 0x40 == u.b[0] && 0 == u.b[3] && 0 == u.b[1] && 0 == u.b[2] ) { // big endian doubles i3 = 0; i2 = 1; } else { // this sitation is not handled by this algorithm // and that is a bug in the algorithm. ON_ERROR("CPU has unexpected bit pattern in float 2.0f."); memset(&x,0xFF,sizeof(*x)); return; } #endif // all exponent bits = 1 // fraction bits = 011...1 u.b[i3] = 0x7F; // 0111 1111 u.b[i2] = 0xA0; // 1010 0000 u.b[3-i2] = 0; // 0... u.b[3-i3] = 0; #if defined(i3) #undef i3 #undef i2 #endif // must use memcpy(). On Intel FPU, assignment using x = u.x // will set x to qnan and invalid op exception occures. memcpy(x,&u.x,sizeof(*x)); }
bool ON_BinaryArchive::ReadCompressedBuffer( // read and uncompress size_t sizeof__outbuffer, // sizeof of uncompressed buffer to read void* outbuffer, // uncompressed output data returned here int* bFailedCRC ) { bool rc = false; unsigned int buffer_crc0 = 0; unsigned int buffer_crc1 = 0; char method = 0; if ( bFailedCRC) *bFailedCRC = false; if ( !ReadMode() ) return false; if ( 0 == sizeof__outbuffer ) return true; if ( 0 == outbuffer ) return false; if ( !ReadInt(&buffer_crc0) ) // 32 bit crc of uncompressed buffer return false; if ( !ReadChar(&method) ) return false; if ( method != 0 && method != 1 ) return false; switch(method) { case 0: // uncompressed rc = ReadByte(sizeof__outbuffer, outbuffer); break; case 1: // compressed rc = CompressionInit(); if (rc) rc = ReadInflate( sizeof__outbuffer, outbuffer ); CompressionEnd(); break; } if (rc ) { buffer_crc1 = ON_CRC32( 0, sizeof__outbuffer, outbuffer ); if ( buffer_crc1 != buffer_crc0 ) { ON_ERROR("ON_BinaryArchive::ReadCompressedBuffer() crc error"); if ( bFailedCRC ) *bFailedCRC = true; } } return rc; }
void log_write_info_arp_icmp(struct log_fd *fd, struct packet_object *po) { struct log_header_info hi; int c, zerr; memset(&hi, 0, sizeof(struct log_header_info)); /* the mac address */ memcpy(&hi.L2_addr, &po->L2.src, MEDIA_ADDR_LEN); /* the ip address */ memcpy(&hi.L3_addr, &po->L3.src, sizeof(struct ip_addr)); /* set the distance */ if (po->L3.ttl > 1) hi.distance = TTL_PREDICTOR(po->L3.ttl) - po->L3.ttl + 1; else hi.distance = po->L3.ttl; /* resolve the host */ host_iptoa(&po->L3.src, hi.hostname); /* local, non local ecc ecc */ if (po->L3.proto == htons(LL_TYPE_ARP)) { hi.type |= LOG_ARP_HOST; hi.type |= FP_HOST_LOCAL; } else { hi.type = po->PASSIVE.flags; } LOG_LOCK; if (fd->type == LOG_COMPRESSED) { c = gzwrite(fd->cfd, &hi, sizeof(hi)); ON_ERROR(c, -1, "%s", gzerror(fd->cfd, &zerr)); } else { c = write(fd->fd, &hi, sizeof(hi)); ON_ERROR(c, -1, "Can't write to logfile"); } LOG_UNLOCK; }
ON_InstanceDefinition::IDEF_UPDATE_TYPE ON_InstanceDefinition::IdefUpdateType() const { if ( ON_InstanceDefinition::embedded_def == m_idef_update_type ) { ON_ERROR("Using obsolete ON_InstanceDefinition::embedded_def value - fix code."); const_cast< ON_InstanceDefinition* >(this)->m_idef_update_type = ( m_source_archive.Length() > 0 ) ? ON_InstanceDefinition::linked_and_embedded_def : ON_InstanceDefinition::static_def; } return m_idef_update_type; }
void ON_SetBinaryArchiveOpenNURBSVersion(ON_BinaryArchive& file, int value) { if ( value >= 200012210 ) { file.m_3dm_opennurbs_version = value; } else { ON_ERROR("ON_SetBinaryArchiveOpenNURBSVersion - invalid opennurbs version"); file.m_3dm_opennurbs_version = 0; } }
bool ON_Quaternion::GetRotation(ON_Xform& xform) const { bool rc; ON_Quaternion q(*this); if ( q.Unitize() ) { if ( fabs(q.a-a) <= ON_ZERO_TOLERANCE && fabs(q.b-b) <= ON_ZERO_TOLERANCE && fabs(q.c-c) <= ON_ZERO_TOLERANCE && fabs(q.d-d) <= ON_ZERO_TOLERANCE ) { // "this" was already unitized - don't tweak bits q = *this; } xform[1][0] = 2.0*(q.b*q.c + q.a*q.d); xform[2][0] = 2.0*(q.b*q.d - q.a*q.c); xform[3][0] = 0.0; xform[0][1] = 2.0*(q.b*q.c - q.a*q.d); xform[2][1] = 2.0*(q.c*q.d + q.a*q.b); xform[3][1] = 0.0; xform[0][2] = 2.0*(q.b*q.d + q.a*q.c); xform[1][2] = 2.0*(q.c*q.d - q.a*q.b); xform[3][2] = 0.0; q.b = q.b*q.b; q.c = q.c*q.c; q.d = q.d*q.d; xform[0][0] = 1.0 - 2.0*(q.c + q.d); xform[1][1] = 1.0 - 2.0*(q.b + q.d); xform[2][2] = 1.0 - 2.0*(q.b + q.c); xform[0][3] = xform[1][3] = xform[2][3] = 0.0; xform[3][3] = 1.0; rc = true; } else if ( IsZero() ) { xform.Zero(); rc = false; } else { // something is seriously wrong ON_ERROR("ON_Quaternion::GetRotation(ON_Xform) quaternion is invalid"); xform.Identity(); rc = false; } return rc; }
void disable_ip_forward(void) { FILE *fd; fd = fopen("/proc/sys/net/ipv4/ip_forward", "r"); ON_ERROR(fd, NULL, "failed to open /proc/sys/net/ipv4/ip_forward"); fscanf(fd, "%c", &saved_status); fclose(fd); DEBUG_MSG("disable_ip_forward: old value = %c", saved_status); fd = fopen("/proc/sys/net/ipv4/ip_forward", "w"); ON_ERROR(fd, NULL, "failed to open /proc/sys/net/ipv4/ip_forward"); fprintf(fd, "0"); fclose(fd); atexit(restore_ip_forward); atexit(regain_privs_atexit); }
void disable_ipv6_forward(void) { FILE *fd; char fpath_global[] = "/proc/sys/net/ipv6/conf/all/forwarding"; char fpath_iface[64]; /* global configuration */ fd = fopen(fpath_global, "r"); ON_ERROR(fd, NULL, "failed to open %s", fpath_global); fscanf(fd, "%c", &saved_status_v6_global); fclose(fd); /* interface specific configuration */ snprintf(fpath_iface, 63, "/proc/sys/net/ipv6/conf/%s/forwarding", EC_GBL_OPTIONS->iface); fd = fopen(fpath_iface, "r"); ON_ERROR(fd, NULL, "failed to open %s", fpath_iface); fscanf(fd, "%c", &saved_status_v6_iface); fclose(fd); fd = fopen(fpath_global, "w"); ON_ERROR(fd, NULL, "failed to open %s", fpath_global); fprintf(fd, "0"); fclose(fd); fd = fopen(fpath_iface, "w"); ON_ERROR(fd, NULL, "failed to open %s", fpath_iface); fprintf(fd, "0"); fclose(fd); DEBUG_MSG("disable_ipv6_forward: old value = %c/%c (global/interface %s)", saved_status_v6_global, saved_status_v6_iface, EC_GBL_OPTIONS->iface); atexit(restore_ipv6_forward); }
static ON_Curve* TuneupEdgeOrTrimRealCurve( ON_CurveProxy& curve, bool bEdge ) { const ON_Curve* real_curve = curve.ProxyCurve(); if ( 0 == real_curve ) return 0; ON_Curve* new_real_curve = 0; const ON_Interval curve_domain = curve.Domain(); if ( curve.ProxyCurveIsReversed() || real_curve->Domain() != curve_domain || curve.ProxyCurveDomain() != curve_domain ) { // The proxy is a subset or reversed real curve. // Make a new real curve that is the exact geometry // the edge or trim requires. if ( bEdge ) { new_real_curve = curve.DuplicateCurve(); } else { // Trim curves end up being converted to piecewise // bezier nurbs curves when their pbox is set, // so do the conversion here and save time and // memory thrashing. ON_NurbsCurve* nurbs_curve = curve.NurbsCurve(); if ( 0 == nurbs_curve ) { // This is a serious error - investigate it. // If you need help, ask Dale Lear. ON_ERROR("trim.NurbsCurve() returned NULL"); new_real_curve = curve.DuplicateCurve(); } else { nurbs_curve->ChangeDimension(2); nurbs_curve->MakePiecewiseBezier(); new_real_curve = nurbs_curve; } } if (0 != new_real_curve) { new_real_curve->SetDomain(curve_domain); } } return new_real_curve; }
int log_write_header(struct log_fd *fd, int type) { struct log_global_header lh; int c, zerr; DEBUG_MSG("log_write_header : type %d", type); memset(&lh, 0, sizeof(struct log_global_header)); /* the magic number */ lh.magic = htons(EC_LOG_MAGIC); /* the offset of the first header is equal to the size of this header */ lh.first_header = htons(sizeof(struct log_global_header)); strlcpy(lh.version, EC_GBL_VERSION, sizeof(lh.version)); /* creation time of the file */ gettimeofday(&lh.tv, 0); lh.tv.tv_sec = htonl(lh.tv.tv_sec); lh.tv.tv_usec = htonl(lh.tv.tv_usec); lh.type = htonl(type); LOG_LOCK; if (fd->type == LOG_COMPRESSED) { c = gzwrite(fd->cfd, &lh, sizeof(lh)); ON_ERROR(c, -1, "%s", gzerror(fd->cfd, &zerr)); } else { c = write(fd->fd, &lh, sizeof(lh)); ON_ERROR(c, -1, "Can't write to logfile"); } LOG_UNLOCK; return c; }
/* * if privacy extension for IPv6 is enabled, under certain * circumstances, an IPv6 socket can not be written exiting with * code -1 bytes written (Cannot assign requested address). * see pull request #245.(https://github.com/Ettercap/ettercap/pull/245) * * this usually happens after returning from hibernation * therefore we should warn users. * * however investigation of the root cause continues but as long as * it isn't identified and fixed, this function is being kept. */ void check_tempaddr(const char *iface) { FILE *fd; int mode_global, mode_iface; char fpath_global[] = "/proc/sys/net/ipv6/conf/all/use_tempaddr"; char fpath_iface[64]; snprintf(fpath_iface, 63, "/proc/sys/net/ipv6/conf/%s/use_tempaddr", iface); fd = fopen(fpath_global, "r"); ON_ERROR(fd, NULL, "failed to open %s", fpath_global); mode_global = fgetc(fd); ON_ERROR(mode_global, EOF, "failed to read value from %s", fpath_global); fclose(fd); DEBUG_MSG("check_tempaddr: %s = %c", fpath_global, mode_global); fd = fopen(fpath_iface, "r"); ON_ERROR(fd, NULL, "failed to open %s", fpath_iface); mode_iface = fgetc(fd); ON_ERROR(mode_iface, EOF, "failed to read value from %s", fpath_iface); fclose(fd); DEBUG_MSG("check_tempaddr: %s = %c", fpath_iface, mode_iface); if (mode_global != '0') USER_MSG("Ettercap might not work correctly. %s is not set to 0.\n", fpath_global); if (mode_iface != '0') USER_MSG("Ettercap might not work correctly. %s is not set to 0.\n", fpath_iface); }
bool ON_BezierCage::MakeRational() { if ( !IsRational() ) { ON_ERROR("TODO: fill in ON_BezierCage::MakeRational()"); /* const int dim = Dimension(); if ( m_order[0] > 0 && m_order[1] > 0 && m_order[2] > 0 && dim > 0 ) { const double* old_cv; double* new_cv; int cvi, cvj, j, cvstride; if ( m_cv_stride[0] < m_cv_stride[1] ) { cvstride = m_cv_stride[0] > dim ? m_cv_stride[0] : dim+1; ReserveCVCapacity( cvstride*m_order[0]*m_order[1] ); new_cv = m_cv + cvstride*m_order[0]*m_order[1]-1; for ( cvj = m_order[1]-1; cvj >= 0; cvj-- ) { for ( cvi = m_order[0]-1; cvi >= 0; cvi-- ) { old_cv = CV(cvi,cvj)+dim-1; *new_cv-- = 1.0; for ( j = 0; j < dim; j++ ) { *new_cv-- = *old_cv--; } } } m_cv_stride[0] = dim+1; m_cv_stride[1] = (dim+1)*m_order[0]; } else { cvstride = m_cv_stride[1] > dim ? m_cv_stride[1] : dim+1; ReserveCVCapacity( cvstride*m_order[0]*m_order[1] ); new_cv = m_cv + cvstride*m_order[0]*m_order[1]-1; for ( cvi = m_order[0]-1; cvi >= 0; cvi-- ) { for ( cvj = m_order[1]-1; cvj >= 0; cvj-- ) { old_cv = CV(cvi,cvj)+dim-1; *new_cv-- = 1.0; for ( j = 0; j < dim; j++ ) { *new_cv-- = *old_cv--; } } } m_cv_stride[1] = dim+1; m_cv_stride[0] = (dim+1)*m_order[1]; } m_is_rat = 1; } */ } return IsRational(); }
static int w2c_size( int w_count, const wchar_t* w ) { // returns number of bytes used in wide conversion. Does not // include NULL terminator. int rc = 0; if ( w ) { unsigned int error_status = 0; rc = ON_ConvertWideCharToUTF8(false,w,w_count,0,0,&error_status,0,0,0); if ( error_status ) { ON_ERROR("Wide char string is not valid."); } if ( rc < 0 ) rc = 0; } return rc; }
bool ON_BezierCage::MakeNonRational() { if ( IsRational() ) { ON_ERROR("TODO: fill in ON_BezierCage::MakeNonRational()"); /* const int dim = Dimension(); if ( m_order[0] > 0 && m_order[1] > 0 && dim > 0 ) { double w; const double* old_cv; double* new_cv = m_cv; int cvi, cvj, j; if ( m_cv_stride[0] < m_cv_stride[1] ) { for ( cvj = 0; cvj < m_order[1]; cvj++ ) { for ( cvi = 0; cvi < m_order[0]; cvi++ ) { old_cv = CV(cvi,cvj); w = old_cv[dim]; w = ( w != 0.0 ) ? 1.0/w : 1.0; for ( j = 0; j < dim; j++ ) { *new_cv++ = w*(*old_cv++); } } } m_cv_stride[0] = dim; m_cv_stride[1] = dim*m_order[0]; } else { for ( cvi = 0; cvi < m_order[0]; cvi++ ) { for ( cvj = 0; cvj < m_order[1]; cvj++ ) { old_cv = CV(cvi,cvj); w = old_cv[dim]; w = ( w != 0.0 ) ? 1.0/w : 1.0; for ( j = 0; j < dim; j++ ) { *new_cv++ = w*(*old_cv++); } } } m_cv_stride[1] = dim; m_cv_stride[0] = dim*m_order[1]; } m_is_rat = 0; } */ } return ( !IsRational() ) ? true : false; }
void capture_init(void) { pcap_t *pd; u_int32 net, mask; struct bpf_program bpf; char pcap_errbuf[PCAP_ERRBUF_SIZE]; DEBUG_MSG("capture_init"); GBL_PCAP->snaplen = 1500 + SLL_HDR_LEN; /* * set the offset of the link layer header to SLL_HDR_LEN * because we open "any" interface, our packet will have a fake * header... look in sad_sarp.h */ GBL_PCAP->offset = SLL_HDR_LEN; pd = pcap_open_live(PCAP_IFACE, GBL_PCAP->snaplen, PCAP_PROMISC, PCAP_TIMEOUT, pcap_errbuf); ON_ERROR(pd, "%s", pcap_errbuf); if (pcap_lookupnet(PCAP_IFACE, &net, &mask, pcap_errbuf) == -1) ERROR_MSG("%s", pcap_errbuf); if (pcap_compile(pd, &bpf, PCAP_FILTER, 1, mask) < 0) ERROR_MSG("%s", pcap_errbuf); if (pcap_setfilter(pd, &bpf) == -1) ERROR_MSG("pcap_setfilter"); GBL_PCAP->fd = pd; atexit(capture_close); /* * and now fill the GBL_PCAP->ifs with the list of network interfaces */ load_ifs(); }