static void test_dtm_set_and_get_system_time(void) { LRESULT r; SYSTEMTIME st, getSt, ref; HWND hWnd, hWndDateTime_test_gdt_none; hWndDateTime_test_gdt_none = create_datetime_control(0); ok(hWndDateTime_test_gdt_none!=NULL, "Expected non NULL, got %p\n", hWndDateTime_test_gdt_none); if(hWndDateTime_test_gdt_none) { r = SendMessage(hWndDateTime_test_gdt_none, DTM_SETSYSTEMTIME, GDT_NONE, (LPARAM)&st); expect(0, r); } else { skip("hWndDateTime_test_gdt_none is NULL\n"); flush_sequences(sequences, NUM_MSG_SEQUENCES); return; } DestroyWindow(hWndDateTime_test_gdt_none); hWnd = create_datetime_control(DTS_SHOWNONE); flush_sequences(sequences, NUM_MSG_SEQUENCES); r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_NONE, (LPARAM)&st); expect(1, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); ok(r == GDT_NONE, "Expected %d, not %d(GDT_VALID) or %d(GDT_ERROR), got %ld\n", GDT_NONE, GDT_VALID, GDT_ERROR, r); /* set st to lowest possible value */ fill_systime_struct(&st, 1601, 1, 0, 1, 0, 0, 0, 0); r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(1, r); /* set st to highest possible value */ fill_systime_struct(&st, 30827, 12, 6, 31, 23, 59, 59, 999); r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(1, r); /* set st to value between min and max */ fill_systime_struct(&st, 1980, 1, 3, 23, 14, 34, 37, 465); r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(1, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); ok(r == GDT_VALID, "Expected %d, not %d(GDT_NONE) or %d(GDT_ERROR), got %ld\n", GDT_VALID, GDT_NONE, GDT_ERROR, r); expect_systime(&st, &getSt); /* set st to invalid value */ fill_systime_struct(&st, 0, 0, 7, 0, 24, 60, 60, 1000); r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect_unsuccess(0, r); ok_sequence(sequences, DATETIME_SEQ_INDEX, test_dtm_set_and_get_system_time_seq, "test_dtm_set_and_get_system_time", FALSE); /* set to some valid value */ GetSystemTime(&ref); r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&ref); expect(1, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* year invalid */ st = ref; st.wYear = 0; r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); todo_wine expect(1, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* month invalid */ st = ref; st.wMonth = 13; r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(0, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* day invalid */ st = ref; st.wDay = 32; r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(0, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* day of week isn't validated */ st = ref; st.wDayOfWeek = 10; r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(1, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* hour invalid */ st = ref; st.wHour = 25; r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(0, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* minute invalid */ st = ref; st.wMinute = 60; r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(0, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* sec invalid */ st = ref; st.wSecond = 60; r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(0, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* msec invalid */ st = ref; st.wMilliseconds = 1000; r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(0, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); expect_systime(&ref, &getSt); /* day of week should be calculated automatically, actual day of week for this date is 4 */ fill_systime_struct(&st, 2009, 10, 1, 1, 0, 0, 10, 200); r = SendMessage(hWnd, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&st); expect(1, r); r = SendMessage(hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)&getSt); expect(GDT_VALID, r); /* 01.10.2009 is Thursday */ expect(4, (LRESULT)getSt.wDayOfWeek); st.wDayOfWeek = 4; expect_systime(&st, &getSt); DestroyWindow(hWnd); }
void MediaView::activeRowChanged(int row) { if (stopped) return; errorTimer->stop(); #ifdef APP_PHONON mediaObject->stop(); #endif if (downloadItem) { downloadItem->stop(); delete downloadItem; downloadItem = 0; currentVideoSize = 0; } Video *video = playlistModel->videoAt(row); if (!video) return; videoAreaWidget->showLoading(video); connect(video, SIGNAL(gotStreamUrl(QUrl)), SLOT(gotStreamUrl(QUrl)), Qt::UniqueConnection); connect(video, SIGNAL(errorStreamUrl(QString)), SLOT(skip()), Qt::UniqueConnection); video->loadStreamUrl(); // video title in titlebar MainWindow::instance()->setWindowTitle(video->title() + " - " + Constants::NAME); // ensure active item is visible if (row != -1) { QModelIndex index = playlistModel->index(row, 0, QModelIndex()); playlistView->scrollTo(index, QAbstractItemView::EnsureVisible); } // enable/disable actions The::globalActions()->value("download")->setEnabled( DownloadManager::instance()->itemForVideo(video) == 0); The::globalActions()->value("previous")->setEnabled(row > 0); The::globalActions()->value("stopafterthis")->setEnabled(true); The::globalActions()->value("related-videos")->setEnabled(true); bool enableDownload = video->license() == Video::LicenseCC; #ifdef APP_ACTIVATION enableDownload = enableDownload || Activation::instance().isLegacy(); #endif #ifdef APP_DOWNLOADS enableDownload = true; #endif QAction *a = The::globalActions()->value("download"); a->setEnabled(enableDownload); a->setVisible(enableDownload); updateSubscriptionAction(video, YTChannel::isSubscribed(video->channelId())); foreach (QAction *action, currentVideoActions) action->setEnabled(true); #ifndef APP_PHONON_SEEK QSlider *slider = MainWindow::instance()->getSlider(); slider->setEnabled(false); slider->setValue(0); #endif if (snapshotSettings) { delete snapshotSettings; snapshotSettings = 0; MainWindow::instance()->adjustStatusBarVisibility(); } // see you in gotStreamUrl... }
// ------------------------------------------------ // Function: parse_dhcp() // ------------------------------------------------ // Input: Message buffer // Output: Opcode or 0xff if failed // ------------------------------------------------ // Description: Parse an incoming DHCP message // ------------------------------------------------ BYTE parse_dhcp(PPBUF pbuf) { BYTE opt; BYTE type, size; // --------------------- // jump to the data area // --------------------- skip(pbuf, BOOTP_HDR_SIZE); opt = 0xff; // ----------------- // check DHCP fields // ----------------- if(DHCP(pbuf->data)->op != 2) return 0xff; if(DHCP(pbuf->data)->xid != xid.d) return 0xff; if(read_uint32(pbuf) != 0x63825363) return 0xff; // ---------------- // update temp data // ---------------- ip_tmp.d = DHCP(pbuf->data)->yi.d; ip_dhcp.d = IPH(pbuf->start)->source.d; // ------------- // parse options // ------------- while(!is_eof(pbuf)) { type = read_byte(pbuf); size = read_byte(pbuf); switch(type) { case DHCP_OPT_TYPE: opt = read_byte(pbuf); skip(pbuf, size-1); break; case DHCP_OPT_MASK: ip_mask[INTERFACE_ETH] = read_ip(pbuf); skip(pbuf, size-4); break; case DHCP_OPT_ROUTER: ip_gateway[INTERFACE_ETH] = read_ip(pbuf); skip(pbuf, size-4); break; #ifdef _DNS case DHCP_OPT_DNS: ip_dns[INTERFACE_ETH] = read_ip(pbuf); skip(pbuf, size-4); break; #endif case DHCP_OPT_END: return opt; break; default: skip(pbuf, size); // ignore other options break; } } return opt; }
/* * Read an ascii label in from FILE f, * in the same format as that put out by display(), * and fill in lp. */ int getasciilabel(FILE *f, struct disklabel *lp) { char **cpp, *cp; const char *errstr; struct partition *pp; char *tp, *s, line[BUFSIZ]; int lineno = 0, errors = 0; u_int32_t v, fsize; u_int64_t lv; lp->d_version = 1; lp->d_bbsize = BBSIZE; /* XXX */ lp->d_sbsize = SBSIZE; /* XXX */ while (fgets(line, sizeof(line), f)) { lineno++; if ((cp = strpbrk(line, "#\r\n"))) *cp = '\0'; cp = skip(line); if (cp == NULL) continue; tp = strchr(cp, ':'); if (tp == NULL) { warnx("line %d: syntax error", lineno); errors++; continue; } *tp++ = '\0', tp = skip(tp); if (!strcmp(cp, "type")) { if (tp == NULL) tp = "unknown"; else if (strcasecmp(tp, "IDE") == 0) tp = "ESDI"; cpp = dktypenames; for (; cpp < &dktypenames[DKMAXTYPES]; cpp++) if ((s = *cpp) && !strcasecmp(s, tp)) { lp->d_type = cpp - dktypenames; goto next; } v = GETNUM(lp->d_type, tp, 0, &errstr); if (errstr || v >= DKMAXTYPES) warnx("line %d: warning, unknown disk type: %s", lineno, tp); lp->d_type = v; continue; } if (!strcmp(cp, "flags")) { for (v = 0; (cp = tp) && *cp != '\0';) { tp = word(cp); if (!strcmp(cp, "badsect")) v |= D_BADSECT; else if (!strcmp(cp, "vendor")) v |= D_VENDOR; else { warnx("line %d: bad flag: %s", lineno, cp); errors++; } } lp->d_flags = v; continue; } if (!strcmp(cp, "drivedata")) { int i; for (i = 0; (cp = tp) && *cp != '\0' && i < NDDATA;) { v = GETNUM(lp->d_drivedata[i], cp, 0, &errstr); if (errstr) warnx("line %d: bad drivedata %s", lineno, cp); lp->d_drivedata[i++] = v; tp = word(cp); } continue; } if (sscanf(cp, "%d partitions", &v) == 1) { if (v == 0 || v > MAXPARTITIONS) { warnx("line %d: bad # of partitions", lineno); lp->d_npartitions = MAXPARTITIONS; errors++; } else lp->d_npartitions = v; continue; } if (tp == NULL) tp = ""; if (!strcmp(cp, "disk")) { strncpy(lp->d_typename, tp, sizeof (lp->d_typename)); continue; } if (!strcmp(cp, "label")) { strncpy(lp->d_packname, tp, sizeof (lp->d_packname)); continue; } if (!strcmp(cp, "duid")) { if (duid_parse(lp, tp) != 0) { warnx("line %d: bad %s: %s", lineno, cp, tp); errors++; } continue; } if (!strcmp(cp, "bytes/sector")) { v = GETNUM(lp->d_secsize, tp, 1, &errstr); if (errstr || (v % 512) != 0) { warnx("line %d: bad %s: %s", lineno, cp, tp); errors++; } else lp->d_secsize = v; continue; } if (!strcmp(cp, "sectors/track")) { v = GETNUM(lp->d_nsectors, tp, 1, &errstr); if (errstr) { warnx("line %d: bad %s: %s", lineno, cp, tp); errors++; } else lp->d_nsectors = v; continue; } if (!strcmp(cp, "sectors/cylinder")) { v = GETNUM(lp->d_secpercyl, tp, 1, &errstr); if (errstr) { warnx("line %d: bad %s: %s", lineno, cp, tp); errors++; } else lp->d_secpercyl = v; continue; } if (!strcmp(cp, "tracks/cylinder")) { v = GETNUM(lp->d_ntracks, tp, 1, &errstr); if (errstr) { warnx("line %d: bad %s: %s", lineno, cp, tp); errors++; } else lp->d_ntracks = v; continue; } if (!strcmp(cp, "cylinders")) { v = GETNUM(lp->d_ncylinders, tp, 1, &errstr); if (errstr) { warnx("line %d: bad %s: %s", lineno, cp, tp); errors++; } else lp->d_ncylinders = v; continue; } /* Ignore fields that are no longer in the disklabel. */ if (!strcmp(cp, "rpm") || !strcmp(cp, "interleave") || !strcmp(cp, "trackskew") || !strcmp(cp, "cylinderskew") || !strcmp(cp, "headswitch") || !strcmp(cp, "track-to-track seek")) continue; /* Ignore fields that are forcibly set when label is read. */ if (!strcmp(cp, "total sectors") || !strcmp(cp, "boundstart") || !strcmp(cp, "boundend")) continue; if ('a' <= *cp && *cp <= 'z' && cp[1] == '\0') { unsigned int part = *cp - 'a'; if (part >= lp->d_npartitions) { if (part >= MAXPARTITIONS) { warnx("line %d: bad partition name: %s", lineno, cp); errors++; continue; } else { lp->d_npartitions = part + 1; } } pp = &lp->d_partitions[part]; #define NXTNUM(n, field, errstr) { \ if (tp == NULL) { \ warnx("line %d: too few fields", lineno); \ errors++; \ break; \ } else \ cp = tp, tp = word(cp), (n) = GETNUM(field, cp, 0, errstr); \ } NXTNUM(lv, lv, &errstr); if (errstr) { warnx("line %d: bad partition size: %s", lineno, cp); errors++; } else { DL_SETPSIZE(pp, lv); } NXTNUM(lv, lv, &errstr); if (errstr) { warnx("line %d: bad partition offset: %s", lineno, cp); errors++; } else { DL_SETPOFFSET(pp, lv); } if (tp == NULL) { pp->p_fstype = FS_UNUSED; goto gottype; } cp = tp, tp = word(cp); cpp = fstypenames; for (; cpp < &fstypenames[FSMAXTYPES]; cpp++) if ((s = *cpp) && !strcasecmp(s, cp)) { pp->p_fstype = cpp - fstypenames; goto gottype; } if (isdigit((unsigned char)*cp)) v = GETNUM(pp->p_fstype, cp, 0, &errstr); else v = FSMAXTYPES; if (errstr || v >= FSMAXTYPES) { warnx("line %d: warning, unknown filesystem type: %s", lineno, cp); v = FS_UNUSED; } pp->p_fstype = v; gottype: switch (pp->p_fstype) { case FS_UNUSED: /* XXX */ if (tp == NULL) /* ok to skip fsize/bsize */ break; NXTNUM(fsize, fsize, &errstr); if (fsize == 0) break; NXTNUM(v, v, &errstr); pp->p_fragblock = DISKLABELV1_FFS_FRAGBLOCK(fsize, v / fsize); break; case FS_BSDFFS: NXTNUM(fsize, fsize, &errstr); if (fsize == 0) break; NXTNUM(v, v, &errstr); pp->p_fragblock = DISKLABELV1_FFS_FRAGBLOCK(fsize, v / fsize); NXTNUM(pp->p_cpg, pp->p_cpg, &errstr); break; default: break; } continue; } warnx("line %d: unknown field: %s", lineno, cp); errors++; next: ; } errors += checklabel(lp); return (errors > 0); }
void collect(void) { int j; Tchar i, *strp, *lim, **argpp, **argppend; int quote; Stack *savnxf; copyf++; nxf->nargs = 0; savnxf = nxf; if (skip()) goto rtn; { char *memp; memp = (char *)savnxf; /* * 1 s structure for the macro descriptor * APERMAC Tchar *'s for pointers into the strings * space for the Tchar's themselves */ memp += sizeof(Stack); /* * CPERMAC = the total # of characters for ALL arguments */ #define CPERMAC 200 #define APERMAC 9 memp += APERMAC * sizeof(Tchar *); memp += CPERMAC * sizeof(Tchar); nxf = (Stack *)memp; } lim = (Tchar *)nxf; argpp = (Tchar **)(savnxf + 1); argppend = &argpp[APERMAC]; SPACETEST(argppend, sizeof(Tchar *)); strp = (Tchar *)argppend; /* * Zero out all the string pointers before filling them in. */ for (j = 0; j < APERMAC; j++) argpp[j] = 0; /* ERROR "savnxf=0x%x,nxf=0x%x,argpp=0x%x,strp=argppend=0x%x, lim=0x%x", * savnxf, nxf, argpp, strp, lim WARN; */ strflg = 0; while (argpp != argppend && !skip()) { *argpp++ = strp; quote = 0; if (cbits(i = getch()) == '"') quote++; else ch = i; while (1) { i = getch(); /* fprintf(stderr, "collect %c %d\n", cbits(i), cbits(i)); */ if (nlflg || (!quote && argpp != argppend && cbits(i) == ' ')) break; /* collects rest into $9 */ if ( quote && cbits(i) == '"' && cbits(i = getch()) != '"') { ch = i; break; } *strp++ = i; if (strflg && strp >= lim) { /* ERROR "strp=0x%x, lim = 0x%x", strp, lim WARN; */ ERROR "Macro argument too long" WARN; copyf--; edone(004); } SPACETEST(strp, 3 * sizeof(Tchar)); } *strp++ = 0; } nxf = savnxf; nxf->nargs = argpp - (Tchar **)(savnxf + 1); argtop = strp; rtn: copyf--; }
QSize QToolBarAreaLayoutItem::minimumSize() const { if (skip()) return QSize(0, 0); return qSmartMinSize(static_cast<QWidgetItem*>(widgetItem)); }
static void test_heap_checks( DWORD flags ) { BYTE old, *p, *p2; BOOL ret; SIZE_T i, size, large_size = 3000 * 1024 + 37; if (flags & HEAP_PAGE_ALLOCS) return; /* no tests for that case yet */ trace( "testing heap flags %08x\n", flags ); p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 17 ); ok( p != NULL, "HeapAlloc failed\n" ); ret = HeapValidate( GetProcessHeap(), 0, p ); ok( ret, "HeapValidate failed\n" ); size = HeapSize( GetProcessHeap(), 0, p ); ok( size == 17, "Wrong size %lu\n", size ); ok( p[14] == 0, "wrong data %x\n", p[14] ); ok( p[15] == 0, "wrong data %x\n", p[15] ); ok( p[16] == 0, "wrong data %x\n", p[16] ); if (flags & HEAP_TAIL_CHECKING_ENABLED) { ok( p[17] == 0xab, "wrong padding %x\n", p[17] ); ok( p[18] == 0xab, "wrong padding %x\n", p[18] ); ok( p[19] == 0xab, "wrong padding %x\n", p[19] ); } p2 = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, p, 14 ); if (p2 == p) { if (flags & HEAP_TAIL_CHECKING_ENABLED) { ok( p[14] == 0xab, "wrong padding %x\n", p[14] ); ok( p[15] == 0xab, "wrong padding %x\n", p[15] ); ok( p[16] == 0xab, "wrong padding %x\n", p[16] ); } else { ok( p[14] == 0, "wrong padding %x\n", p[14] ); ok( p[15] == 0, "wrong padding %x\n", p[15] ); } } else skip( "realloc in place failed\n"); ret = HeapFree( GetProcessHeap(), 0, p ); ok( ret, "HeapFree failed\n" ); p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 17 ); ok( p != NULL, "HeapAlloc failed\n" ); old = p[17]; p[17] = 0xcc; if (flags & HEAP_TAIL_CHECKING_ENABLED) { ret = HeapValidate( GetProcessHeap(), 0, p ); ok( !ret, "HeapValidate succeeded\n" ); /* other calls only check when HEAP_VALIDATE is set */ if (flags & HEAP_VALIDATE) { size = HeapSize( GetProcessHeap(), 0, p ); ok( size == ~(SIZE_T)0 || broken(size == ~0u), "Wrong size %lu\n", size ); p2 = HeapReAlloc( GetProcessHeap(), 0, p, 14 ); ok( p2 == NULL, "HeapReAlloc succeeded\n" ); ret = HeapFree( GetProcessHeap(), 0, p ); ok( !ret || broken(sizeof(void*) == 8), /* not caught on xp64 */ "HeapFree succeeded\n" ); } p[17] = old; size = HeapSize( GetProcessHeap(), 0, p ); ok( size == 17, "Wrong size %lu\n", size ); p2 = HeapReAlloc( GetProcessHeap(), 0, p, 14 ); ok( p2 != NULL, "HeapReAlloc failed\n" ); p = p2; } ret = HeapFree( GetProcessHeap(), 0, p ); ok( ret, "HeapFree failed\n" ); p = HeapAlloc( GetProcessHeap(), 0, 37 ); ok( p != NULL, "HeapAlloc failed\n" ); memset( p, 0xcc, 37 ); ret = HeapFree( GetProcessHeap(), 0, p ); ok( ret, "HeapFree failed\n" ); if (flags & HEAP_FREE_CHECKING_ENABLED) { ok( p[16] == 0xee, "wrong data %x\n", p[16] ); ok( p[17] == 0xfe, "wrong data %x\n", p[17] ); ok( p[18] == 0xee, "wrong data %x\n", p[18] ); ok( p[19] == 0xfe, "wrong data %x\n", p[19] ); ret = HeapValidate( GetProcessHeap(), 0, NULL ); ok( ret, "HeapValidate failed\n" ); old = p[16]; p[16] = 0xcc; ret = HeapValidate( GetProcessHeap(), 0, NULL ); ok( !ret, "HeapValidate succeeded\n" ); p[16] = old; ret = HeapValidate( GetProcessHeap(), 0, NULL ); ok( ret, "HeapValidate failed\n" ); } /* now test large blocks */ p = HeapAlloc( GetProcessHeap(), 0, large_size ); ok( p != NULL, "HeapAlloc failed\n" ); ret = HeapValidate( GetProcessHeap(), 0, p ); ok( ret, "HeapValidate failed\n" ); size = HeapSize( GetProcessHeap(), 0, p ); ok( size == large_size, "Wrong size %lu\n", size ); ok( p[large_size - 2] == 0, "wrong data %x\n", p[large_size - 2] ); ok( p[large_size - 1] == 0, "wrong data %x\n", p[large_size - 1] ); if (flags & HEAP_TAIL_CHECKING_ENABLED) { /* Windows doesn't do tail checking on large blocks */ ok( p[large_size] == 0xab || broken(p[large_size] == 0), "wrong data %x\n", p[large_size] ); ok( p[large_size+1] == 0xab || broken(p[large_size+1] == 0), "wrong data %x\n", p[large_size+1] ); ok( p[large_size+2] == 0xab || broken(p[large_size+2] == 0), "wrong data %x\n", p[large_size+2] ); if (p[large_size] == 0xab) { p[large_size] = 0xcc; ret = HeapValidate( GetProcessHeap(), 0, p ); ok( !ret, "HeapValidate succeeded\n" ); /* other calls only check when HEAP_VALIDATE is set */ if (flags & HEAP_VALIDATE) { size = HeapSize( GetProcessHeap(), 0, p ); ok( size == ~(SIZE_T)0, "Wrong size %lu\n", size ); p2 = HeapReAlloc( GetProcessHeap(), 0, p, large_size - 3 ); ok( p2 == NULL, "HeapReAlloc succeeded\n" ); ret = HeapFree( GetProcessHeap(), 0, p ); ok( !ret, "HeapFree succeeded\n" ); } p[large_size] = 0xab; } } ret = HeapFree( GetProcessHeap(), 0, p ); ok( ret, "HeapFree failed\n" ); /* test block sizes when tail checking */ if (flags & HEAP_TAIL_CHECKING_ENABLED) { for (size = 0; size < 64; size++) { p = HeapAlloc( GetProcessHeap(), 0, size ); for (i = 0; i < 32; i++) if (p[size + i] != 0xab) break; ok( i >= 8, "only %lu tail bytes for size %lu\n", i, size ); HeapFree( GetProcessHeap(), 0, p ); } } }
static void test_install_svc_from(void) { char inf[2048]; char path[MAX_PATH]; HINF infhandle; BOOL ret; SC_HANDLE scm_handle, svc_handle; /* Bail out if we are on win98 */ SetLastError(0xdeadbeef); scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL); if (!scm_handle && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) { win_skip("OpenSCManagerA is not implemented, we are most likely on win9x\n"); return; } CloseServiceHandle(scm_handle); /* Basic inf file to satisfy SetupOpenInfFileA */ strcpy(inf, "[Version]\nSignature=\"$Chicago$\"\n"); create_inf_file(inffile, inf); sprintf(path, "%s\\%s", CURR_DIR, inffile); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); /* Nothing but the Version section */ SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0); ok(!ret, "Expected failure\n"); ok(GetLastError() == ERROR_SECTION_NOT_FOUND, "Expected ERROR_SECTION_NOT_FOUND, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); /* Add the section */ strcat(inf, "[Winetest.Services]\n"); create_inf_file(inffile, inf); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0); ok(!ret, "Expected failure\n"); ok(GetLastError() == ERROR_SECTION_NOT_FOUND, "Expected ERROR_SECTION_NOT_FOUND, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); /* Add a reference */ strcat(inf, "AddService=Winetest,,Winetest.Service\n"); create_inf_file(inffile, inf); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0); ok(!ret, "Expected failure\n"); ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT, "Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); /* Add the section */ strcat(inf, "[Winetest.Service]\n"); create_inf_file(inffile, inf); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0); ok(!ret, "Expected failure\n"); ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT, "Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); /* Just the ServiceBinary */ strcat(inf, "ServiceBinary=%12%\\winetest.sys\n"); create_inf_file(inffile, inf); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0); ok(!ret, "Expected failure\n"); ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT, "Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); /* Add the ServiceType */ strcat(inf, "ServiceType=1\n"); create_inf_file(inffile, inf); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0); ok(!ret, "Expected failure\n"); ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT, "Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); /* Add the StartType */ strcat(inf, "StartType=4\n"); create_inf_file(inffile, inf); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0); ok(!ret, "Expected failure\n"); ok(GetLastError() == ERROR_BAD_SERVICE_INSTALLSECT, "Expected ERROR_BAD_SERVICE_INSTALLSECT, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); /* This should be it, the minimal entries to install a service */ strcat(inf, "ErrorControl=1"); create_inf_file(inffile, inf); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "Winetest.Services", 0); if (!ret && GetLastError() == ERROR_ACCESS_DENIED) { skip("Not enough rights to install the service\n"); SetupCloseInfFile(infhandle); DeleteFileA(inffile); return; } ok(ret, "Expected success\n"); ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL); /* Open the service to see if it's really there */ svc_handle = OpenServiceA(scm_handle, "Winetest", DELETE); ok(svc_handle != NULL, "Service was not created\n"); SetLastError(0xdeadbeef); ret = DeleteService(svc_handle); ok(ret, "Service could not be deleted : %d\n", GetLastError()); CloseServiceHandle(svc_handle); CloseServiceHandle(scm_handle); strcpy(inf, "[Version]\nSignature=\"$Chicago$\"\n"); strcat(inf, "[XSP.InstallPerVer]\n"); strcat(inf, "AddReg=AspEventlogMsg.Reg,Perf.Reg,AspVersions.Reg,FreeADO.Reg,IndexServer.Reg\n"); create_inf_file(inffile, inf); sprintf(path, "%s\\%s", CURR_DIR, inffile); infhandle = SetupOpenInfFileA(path, NULL, INF_STYLE_WIN4, NULL); SetLastError(0xdeadbeef); ret = SetupInstallServicesFromInfSectionA(infhandle, "XSP.InstallPerVer", 0); ok(ret, "Expected success\n"); ok(GetLastError() == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %08x\n", GetLastError()); SetupCloseInfFile(infhandle); DeleteFileA(inffile); /* TODO: Test the Flags */ }
static void test_driver_install(void) { HANDLE handle; SC_HANDLE scm_handle, svc_handle; BOOL ret; char path[MAX_PATH], windir[MAX_PATH], driver[MAX_PATH]; DWORD attrs; /* Minimal stuff needed */ static const char *inf = "[Version]\n" "Signature=\"$Chicago$\"\n" "[DestinationDirs]\n" "Winetest.DriverFiles=12\n" "[DefaultInstall]\n" "CopyFiles=Winetest.DriverFiles\n" "[DefaultInstall.Services]\n" "AddService=Winetest,,Winetest.Service\n" "[Winetest.Service]\n" "ServiceBinary=%12%\\winetest.sys\n" "ServiceType=1\n" "StartType=4\n" "ErrorControl=1\n" "[Winetest.DriverFiles]\n" "winetest.sys"; /* Bail out if we are on win98 */ SetLastError(0xdeadbeef); scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL); if (!scm_handle && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)) { win_skip("OpenSCManagerA is not implemented, we are most likely on win9x\n"); return; } else if (!scm_handle && (GetLastError() == ERROR_ACCESS_DENIED)) { skip("Not enough rights to install the service\n"); return; } CloseServiceHandle(scm_handle); /* Place where we expect the driver to be installed */ GetWindowsDirectoryA(windir, MAX_PATH); lstrcpyA(driver, windir); lstrcatA(driver, "\\system32\\drivers\\winetest.sys"); /* Create a dummy driver file */ handle = CreateFileA("winetest.sys", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); CloseHandle(handle); create_inf_file(inffile, inf); sprintf(path, "%s\\%s", CURR_DIR, inffile); run_cmdline("DefaultInstall", 128, path); /* Driver should have been installed */ attrs = GetFileAttributesA(driver); ok(attrs != INVALID_FILE_ATTRIBUTES, "Expected driver to exist\n"); scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL); /* Open the service to see if it's really there */ svc_handle = OpenServiceA(scm_handle, "Winetest", DELETE); ok(svc_handle != NULL, "Service was not created\n"); SetLastError(0xdeadbeef); ret = DeleteService(svc_handle); ok(ret, "Service could not be deleted : %d\n", GetLastError()); CloseServiceHandle(svc_handle); CloseServiceHandle(scm_handle); /* File cleanup */ DeleteFileA(inffile); DeleteFileA("winetest.sys"); DeleteFileA(driver); }
/** \fn nextPacket \brief Read ASF packet & segments Flags are bitwise OR of: 0x40 Explicit packet size specified word16 0X60 Means word32 0x20 Explicit packet size specified byte 0x10 16-bit padding size specified 0x18 means word32 0x08 8-bit padding size specified 0x04 sequence coded in word16 0x02 sequence coded in byte 0x01 More than one segment Docs from http://avifile.sourceforge.net/asf-1.0.htm completed by mplayer code */ uint8_t asfPacket::nextPacket(uint8_t streamWanted) { uint64_t dts; uint32_t aduration,nbSeg,payloadLengthType=0x80; uint32_t sequenceLen,len,streamId; int32_t packetLen=0; uint32_t paddingLen; int lengthTypeFlags,propertyFlags,multiplePayloadPresent; int sequenceType,sequence,offsetLenType,replicaLenType,streamNumberLenType,mediaObjectNumberLenType; packetStart=ftello(_fd); _offset=0; int r82=read8(); if(r82!=0x82) { printf("[ASF PACKET]At pos 0x%" PRIx64" \n",(uint64_t)ftello(_fd)); printf("[ASF PACKET]not a 82 packet but 0x%x\n",r82); return 0; } aprintf("============== New packet ===============\n"); read16(); // Always 0 ???? // / end of error correction // Payload parsing information packetLen=0; paddingLen=0; sequenceType=0; sequenceLen=0; sequence=0; offsetLenType=0; replicaLenType=0; streamNumberLenType=0; mediaObjectNumberLenType=0; lengthTypeFlags=read8(); propertyFlags=read8(); multiplePayloadPresent=lengthTypeFlags&1; // Read packetLen packetLen=readVCL(lengthTypeFlags>>5,pakSize); // Sequence len sequenceLen=readVCL(lengthTypeFlags>>1,0); // Read padding size (padding): paddingLen=readVCL(lengthTypeFlags>>3,0); // replicaLenType=(propertyFlags>>0)&3; offsetLenType=(propertyFlags>>2)&3; mediaObjectNumberLenType=(propertyFlags>>4)&3; streamNumberLenType=(propertyFlags>>6)&3; // Send time dts=1000*read32(); // Send time (ms) aduration=read16(); // Duration (ms) aprintf(":: Time 1 %s\n",ADM_us2plain(dts)); if(!packetLen) { // Padding (relative) size packetLen=pakSize-_offset; packetLen=packetLen-paddingLen; } int mediaObjectNumber, offset,replica,r; int32_t remaining; uint32_t payloadLen; uint32_t keyframe; // Multi payload if(multiplePayloadPresent) { uint8_t r=read8(); nbSeg=r&0x3f; payloadLengthType=r>>6; aprintf("Multiple Payload :%d\n",(int)nbSeg); // Now read Segments.... // for(int seg=0;seg<nbSeg;seg++) { r=read8(); // Read stream Id uint64_t pts=ADM_NO_PTS; if(r&0x80) { keyframe=AVI_KEY_FRAME; aprintf(">>>KeyFrame\n"); } else keyframe=0; streamId=r&0x7f; //printf(">>>>>Stream Id : %x, duration %d ms, send time:%d ms <<<<<\n",streamId,aduration,dts); mediaObjectNumber=readVCL(mediaObjectNumberLenType,0); // Media object number offset=readVCL(offsetLenType,0); replica=readVCL(replicaLenType,0); pts=readPtsFromReplica(replica); payloadLen=readVCL(payloadLengthType,0); remaining=pakSize-_offset; remaining=remaining-paddingLen; if(remaining<=0) { ADM_warning("** Err: No data left (%d)\n",remaining); } if(!payloadLen) { payloadLen=remaining; } if(remaining<payloadLen) { ADM_warning("** WARNING too big %d %d\n", remaining,packetLen); payloadLen=remaining; } // else we read "payloadLen" bytes and put them at offset "offset" if(streamId==streamWanted|| streamWanted==0xff) { pushPacket(keyframe,currentPacket,offset,mediaObjectNumber,payloadLen,streamId,dts,pts); dts=ADM_NO_PTS; }else skip(payloadLen); } } else { // single payload
static void testGetDllDirectory(void) { CHAR bufferA[MAX_PATH]; WCHAR bufferW[MAX_PATH]; DWORD length, ret; int i; static const char *dll_directories[] = { "", "C:\\Some\\Path", "C:\\Some\\Path\\", "Q:\\A\\Long\\Path with spaces that\\probably\\doesn't exist!", }; const int test_count = sizeof(dll_directories) / sizeof(dll_directories[0]); if (!pGetDllDirectoryA || !pGetDllDirectoryW) { win_skip("GetDllDirectory not available\n"); return; } if (!pSetDllDirectoryA) { win_skip("SetDllDirectoryA not available\n"); return; } for (i = 0; i < test_count; i++) { length = strlen(dll_directories[i]); if (!pSetDllDirectoryA(dll_directories[i])) { skip("i=%d, SetDllDirectoryA failed\n", i); continue; } /* no buffer, determine length */ ret = pGetDllDirectoryA(0, NULL); ok(ret == length + 1, "Expected %u, got %u\n", length + 1, ret); ret = pGetDllDirectoryW(0, NULL); ok(ret == length + 1, "Expected %u, got %u\n", length + 1, ret); /* buffer of exactly the right size */ bufferA[length] = 'A'; bufferA[length + 1] = 'A'; ret = pGetDllDirectoryA(length + 1, bufferA); ok(ret == length || broken(ret + 1 == length) /* win8 */, "i=%d, Expected %u(+1), got %u\n", i, length, ret); ok(bufferA[length + 1] == 'A', "i=%d, Buffer overflow\n", i); ok(strcmp(bufferA, dll_directories[i]) == 0, "i=%d, Wrong path returned: '%s'\n", i, bufferA); bufferW[length] = 'A'; bufferW[length + 1] = 'A'; ret = pGetDllDirectoryW(length + 1, bufferW); ok(ret == length, "i=%d, Expected %u, got %u\n", i, length, ret); ok(bufferW[length + 1] == 'A', "i=%d, Buffer overflow\n", i); ok(cmpStrAW(dll_directories[i], bufferW, length, length), "i=%d, Wrong path returned: %s\n", i, wine_dbgstr_w(bufferW)); /* Zero size buffer. The buffer may or may not be terminated depending * on the Windows version and whether the A or W API is called. */ bufferA[0] = 'A'; ret = pGetDllDirectoryA(0, bufferA); ok(ret == length + 1, "i=%d, Expected %u, got %u\n", i, length + 1, ret); bufferW[0] = 'A'; ret = pGetDllDirectoryW(0, bufferW); ok(ret == length + 1, "i=%d, Expected %u, got %u\n", i, length + 1, ret); ok(bufferW[0] == 0 || /* XP, 2003 */ broken(bufferW[0] == 'A'), "i=%d, Buffer overflow\n", i); /* buffer just one too short */ bufferA[0] = 'A'; ret = pGetDllDirectoryA(length, bufferA); ok(ret == length + 1, "i=%d, Expected %u, got %u\n", i, length + 1, ret); if (length != 0) ok(bufferA[0] == 0, "i=%d, Buffer not null terminated\n", i); bufferW[0] = 'A'; ret = pGetDllDirectoryW(length, bufferW); ok(ret == length + 1, "i=%d, Expected %u, got %u\n", i, length + 1, ret); ok(bufferW[0] == 0 || /* XP, 2003 */ broken(bufferW[0] == 'A'), "i=%d, Buffer overflow\n", i); if (0) { /* crashes on win8 */ /* no buffer, but too short length */ ret = pGetDllDirectoryA(length, NULL); ok(ret == length + 1, "i=%d, Expected %u, got %u\n", i, length + 1, ret); ret = pGetDllDirectoryW(length, NULL); ok(ret == length + 1, "i=%d, Expected %u, got %u\n", i, length + 1, ret); } } /* unset whatever we did so following tests won't be affected */ pSetDllDirectoryA(NULL); }
void setdraw(void) /* generate internal cookies for a drawing function */ { int i, j, k, dx[NPAIR], dy[NPAIR], delim, type; Tchar c, drawbuf[NC]; int drawch = '.'; /* character to draw with */ /* input is \D'f dx dy dx dy ... c' (or at least it had better be) */ /* this does drawing function f with character c and the */ /* specified dx,dy pairs interpreted as appropriate */ /* pairs are deltas from last point, except for radii */ /* l dx dy: line from here by dx,dy */ /* c x: circle of diameter x, left side here */ /* e x y: ellipse of diameters x,y, left side here */ /* a dx1 dy1 dx2 dy2: ccw arc: ctr at dx1,dy1, then end at dx2,dy2 from there */ /* ~ dx1 dy1 dx2 dy2...: spline to dx1,dy1 to dx2,dy2 ... */ /* b x c: built-up character of type c, ht x */ /* f dx dy ...: f is any other char: like spline */ if (ismot(c = getch())) return; delim = cbits(c); numerr.escarg = type = cbits(getch()); if (type == '~') /* head off the .tr ~ problem */ type = 's'; for (i = 0; i < NPAIR ; i++) { skip(); vflag = 0; dfact = EM; dx[i] = quant(atoi0(), HOR); if (dx[i] > MAXMOT) dx[i] = MAXMOT; else if (dx[i] < -MAXMOT) dx[i] = -MAXMOT; skip(); if (type == 'c') { dy[i] = 0; goto eat; } vflag = 1; dfact = lss; dy[i] = quant(atoi0(), VERT); if (dy[i] > MAXMOT) dy[i] = MAXMOT; else if (dy[i] < -MAXMOT) dy[i] = -MAXMOT; eat: if (cbits(c = getch()) != ' ') { /* must be the end */ if (cbits(c) != delim) { drawch = cbits(c); getch(); } i++; break; } } dfact = 1; vflag = 0; if (TROFF) { drawbuf[0] = DRAWFCN | chbits | ZBIT; drawbuf[1] = type | chbits | ZBIT; drawbuf[2] = drawch | chbits | ZBIT; for (k = 0, j = 3; k < i; k++) { drawbuf[j++] = MOT | ((dx[k] >= 0) ? dx[k] : (NMOT | -dx[k])); drawbuf[j++] = MOT | VMOT | ((dy[k] >= 0) ? dy[k] : (NMOT | -dy[k])); } if (type == DRAWELLIPSE) { drawbuf[5] = drawbuf[4] | NMOT; /* so the net vertical is zero */ j = 6; } else if (type == DRAWBUILD) { drawbuf[4] = drawbuf[3] | NMOT; /* net horizontal motion is zero */ drawbuf[2] &= ~ZBIT; /* width taken from drawing char */ j = 5; } drawbuf[j++] = DRAWFCN | chbits | ZBIT; /* marks end for ptout */ drawbuf[j] = 0; pushback(drawbuf); } }
static void setperusersecvalues_test(void) { PERUSERSECTIONA peruser; HRESULT hr; HKEY guid; lstrcpyA(peruser.szDispName, "displayname"); lstrcpyA(peruser.szLocale, "locale"); lstrcpyA(peruser.szStub, "stub"); lstrcpyA(peruser.szVersion, "1,1,1,1"); lstrcpyA(peruser.szCompID, "compid"); peruser.dwIsInstalled = 1; peruser.bRollback = FALSE; /* try a NULL pPerUser */ if (0) { /* This crashes on systems with IE7 */ hr = pSetPerUserSecValues(NULL); todo_wine ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!OPEN_GUID_KEY(), "Expected guid key to not exist\n"); } /* at the very least, szGUID must be valid */ peruser.szGUID[0] = '\0'; hr = pSetPerUserSecValues(&peruser); ok(hr == S_OK, "Expected S_OK, got %d\n", hr); ok(!OPEN_GUID_KEY(), "Expected guid key to not exist\n"); /* set initial values */ lstrcpyA(peruser.szGUID, "guid"); hr = pSetPerUserSecValues(&peruser); if (hr == E_FAIL) { skip("SetPerUserSecValues is broken\n"); return; } ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(OPEN_GUID_KEY(), "Expected guid key to exist\n"); ok(check_reg_str(guid, NULL, "displayname"), "Expected displayname\n"); ok(check_reg_str(guid, "ComponentID", "compid"), "Expected compid\n"); ok(check_reg_str(guid, "Locale", "locale"), "Expected locale\n"); ok(check_reg_str(guid, "StubPath", "stub"), "Expected stub\n"); ok(check_reg_str(guid, "Version", "1,1,1,1"), "Expected 1,1,1,1\n"); ok(check_reg_dword(guid, "IsInstalled", 1), "Expected 1\n"); ok(!REG_VAL_EXISTS(guid, "OldDisplayName"), "Expected OldDisplayName to not exist\n"); ok(!REG_VAL_EXISTS(guid, "OldLocale"), "Expected OldLocale to not exist\n"); ok(!REG_VAL_EXISTS(guid, "OldStubPath"), "Expected OldStubPath to not exist\n"); ok(!REG_VAL_EXISTS(guid, "OldVersion"), "Expected OldVersion to not exist\n"); ok(!REG_VAL_EXISTS(guid, "RealStubPath"), "Expected RealStubPath to not exist\n"); /* raise the version, but bRollback is FALSE, so vals not saved */ lstrcpyA(peruser.szVersion, "2,1,1,1"); hr = pSetPerUserSecValues(&peruser); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(check_reg_str(guid, NULL, "displayname"), "Expected displayname\n"); ok(check_reg_str(guid, "ComponentID", "compid"), "Expected compid\n"); ok(check_reg_str(guid, "Locale", "locale"), "Expected locale\n"); ok(check_reg_str(guid, "StubPath", "stub"), "Expected stub\n"); ok(check_reg_str(guid, "Version", "2,1,1,1"), "Expected 2,1,1,1\n"); ok(check_reg_dword(guid, "IsInstalled", 1), "Expected 1\n"); ok(!REG_VAL_EXISTS(guid, "OldDisplayName"), "Expected OldDisplayName to not exist\n"); ok(!REG_VAL_EXISTS(guid, "OldLocale"), "Expected OldLocale to not exist\n"); ok(!REG_VAL_EXISTS(guid, "OldStubPath"), "Expected OldStubPath to not exist\n"); ok(!REG_VAL_EXISTS(guid, "OldVersion"), "Expected OldVersion to not exist\n"); ok(!REG_VAL_EXISTS(guid, "RealStubPath"), "Expected RealStubPath to not exist\n"); /* raise the version again, bRollback is TRUE so vals are saved */ peruser.bRollback = TRUE; lstrcpyA(peruser.szVersion, "3,1,1,1"); hr = pSetPerUserSecValues(&peruser); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(check_reg_str(guid, NULL, "displayname"), "Expected displayname\n"); ok(check_reg_str(guid, "ComponentID", "compid"), "Expected compid\n"); ok(check_reg_str(guid, "Locale", "locale"), "Expected locale\n"); ok(check_reg_dword(guid, "IsInstalled", 1), "Expected 1\n"); ok(check_reg_str(guid, "Version", "3,1,1,1"), "Expected 3,1,1,1\n"); todo_wine { ok(check_reg_str(guid, "OldDisplayName", "displayname"), "Expected displayname\n"); ok(check_reg_str(guid, "OldLocale", "locale"), "Expected locale\n"); ok(check_reg_str(guid, "RealStubPath", "stub"), "Expected stub\n"); ok(check_reg_str(guid, "OldStubPath", "stub"), "Expected stub\n"); ok(check_reg_str(guid, "OldVersion", "2,1,1,1"), "Expected 2,1,1,1\n"); ok(check_reg_str(guid, "StubPath", "rundll32.exe advpack.dll,UserInstStubWrapper guid"), "Expected real stub\n"); } RegDeleteKeyA(HKEY_LOCAL_MACHINE, GUID_KEY); }
static void translateinfstring_test(void) { HRESULT hr; char buffer[MAX_PATH]; DWORD dwSize; create_inf_file(); /* pass in a couple invalid parameters */ hr = pTranslateInfString(NULL, NULL, NULL, NULL, buffer, MAX_PATH, &dwSize, NULL); ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", (UINT)hr); /* try to open an inf file that doesn't exist */ hr = pTranslateInfString("c:\\a.inf", "Options.NTx86", "Options.NTx86", "InstallDir", buffer, MAX_PATH, &dwSize, NULL); ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || hr == E_INVALIDARG || hr == HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND), "Expected E_INVALIDARG, 0x80070002 or 0x8007007e, got 0x%08x\n", (UINT)hr); if(hr == HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND)) { win_skip("WinNT 3.51 detected. Skipping tests for TranslateInfString()\n"); return; } /* try a nonexistent section */ buffer[0] = 0; hr = pTranslateInfString(inf_file, "idontexist", "Options.NTx86", "InstallDir", buffer, MAX_PATH, &dwSize, NULL); if (hr == E_ACCESSDENIED) { skip("TranslateInfString is broken\n"); return; } ok(hr == S_OK, "Expected S_OK, got 0x%08x\n", (UINT)hr); ok(!strcmp(buffer, TEST_STRING2), "Expected %s, got %s\n", TEST_STRING2, buffer); ok(dwSize == 25, "Expected size 25, got %d\n", dwSize); buffer[0] = 0; /* try other nonexistent section */ hr = pTranslateInfString(inf_file, "Options.NTx86", "idontexist", "InstallDir", buffer, MAX_PATH, &dwSize, NULL); ok(hr == SPAPI_E_LINE_NOT_FOUND || hr == E_INVALIDARG, "Expected SPAPI_E_LINE_NOT_FOUND or E_INVALIDARG, got 0x%08x\n", (UINT)hr); buffer[0] = 0; /* try nonexistent key */ hr = pTranslateInfString(inf_file, "Options.NTx86", "Options.NTx86", "notvalid", buffer, MAX_PATH, &dwSize, NULL); ok(hr == SPAPI_E_LINE_NOT_FOUND || hr == E_INVALIDARG, "Expected SPAPI_E_LINE_NOT_FOUND or E_INVALIDARG, got 0x%08x\n", (UINT)hr); buffer[0] = 0; /* test the behavior of pszInstallSection */ hr = pTranslateInfString(inf_file, "section", "Options.NTx86", "InstallDir", buffer, MAX_PATH, &dwSize, NULL); ok(hr == ERROR_SUCCESS || hr == E_FAIL, "Expected ERROR_SUCCESS or E_FAIL, got 0x%08x\n", (UINT)hr); if(hr == ERROR_SUCCESS) { ok(!strcmp(buffer, APP_PATH), "Expected '%s', got '%s'\n", APP_PATH, buffer); ok(dwSize == APP_PATH_LEN, "Expected size %d, got %d\n", APP_PATH_LEN, dwSize); } buffer[0] = 0; /* try without a pszInstallSection */ hr = pTranslateInfString(inf_file, NULL, "Options.NTx86", "InstallDir", buffer, MAX_PATH, &dwSize, NULL); ok(hr == S_OK, "Expected S_OK, got 0x%08x\n", (UINT)hr); todo_wine { ok(!strcmp(buffer, TEST_STRING2), "Expected %s, got %s\n", TEST_STRING2, buffer); ok(dwSize == 25, "Expected size 25, got %d\n", dwSize); } DeleteFileA("c:\\a.inf"); DeleteFileA(inf_file); }
static void tests(void) { { const char *password = "******"; const char *salt = "salt"; const int iterations = 1; const uint8_t expected[20] = { 0x0c, 0x60, 0xc8, 0x0f, 0x96, 0x1f, 0x0e, 0x71, 0xf3, 0xa9, 0xb5, 0x24, 0xaf, 0x60, 0x12, 0x06, 0x2f, 0xe0, 0x37, 0xa6 }; const char resultSize = sizeof(expected); uint8_t actual[resultSize]; pbkdf2_hmac_sha1((const uint8_t*) password, strlen(password), (const uint8_t*) salt, strlen(salt), iterations, actual, resultSize); ok(memcmp(expected, actual, resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1"); } { const char *password = "******"; const char *salt = "salt"; const int iterations = 2; const uint8_t expected[20] = { 0xea, 0x6c, 0x01, 0x4d, 0xc7, 0x2d, 0x6f, 0x8c, 0xcd, 0x1e, 0xd9, 0x2a, 0xce, 0x1d, 0x41, 0xf0, 0xd8, 0xde, 0x89, 0x57 }; const char resultSize = sizeof(expected); uint8_t actual[resultSize]; pbkdf2_hmac_sha1((const uint8_t*) password, strlen(password), (const uint8_t*) salt, strlen(salt), iterations, actual, resultSize); ok(memcmp(expected, actual, resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-2"); } { const char *password = "******"; const char *salt = "salt"; const int iterations = 4096; const uint8_t expected[20] = { 0x4b, 0x00, 0x79, 0x01, 0xb7, 0x65, 0x48, 0x9a, 0xbe, 0xad, 0x49, 0xd9, 0x26, 0xf7, 0x21, 0xd0, 0x65, 0xa4, 0x29, 0xc1 }; const char resultSize = sizeof(expected); uint8_t actual[resultSize]; pbkdf2_hmac_sha1((const uint8_t*) password, strlen(password), (const uint8_t*) salt, strlen(salt), iterations, actual, resultSize); ok(memcmp(expected, actual, resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-4096"); } SKIP: { skip("16777216 iterations is too slow", 1, 0); const char *password = "******"; const char *salt = "salt"; const int iterations = 16777216; const uint8_t expected[20] = { 0xee, 0xfe, 0x3d, 0x61, 0xcd, 0x4d, 0xa4, 0xe4, 0xe9, 0x94, 0x5b, 0x3d, 0x6b, 0xa2, 0x15, 0x8c, 0x26, 0x34, 0xe9, 0x84 }; const char resultSize = sizeof(expected); uint8_t actual[resultSize]; pbkdf2_hmac_sha1((const uint8_t*) password, strlen(password), (const uint8_t*) salt, strlen(salt), iterations, actual, resultSize); ok(memcmp(expected, actual, resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-16777216"); } { CFStringRef password = CFStringCreateWithCString(NULL, "password", kCFStringEncodingUTF8); CFStringRef salt = CFStringCreateWithCString(NULL, "salt", kCFStringEncodingUTF8); CFDataRef passwordData = CFStringCreateExternalRepresentation(NULL, password, kCFStringEncodingUTF8, 0); CFDataRef saltData = CFStringCreateExternalRepresentation(NULL, salt, kCFStringEncodingUTF8, 0); const int iterations = 1; const uint8_t expected[20] = { 0x0c, 0x60, 0xc8, 0x0f, 0x96, 0x1f, 0x0e, 0x71, 0xf3, 0xa9, 0xb5, 0x24, 0xaf, 0x60, 0x12, 0x06, 0x2f, 0xe0, 0x37, 0xa6 }; const char resultSize = sizeof(expected); CFMutableDataRef resultData = CFDataCreateMutable(NULL, resultSize); CFDataIncreaseLength(resultData, resultSize); SecKeyFromPassphraseDataHMACSHA1(passwordData, saltData, iterations, resultData); ok(memcmp(expected, CFDataGetBytePtr(resultData), resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1"); CFReleaseSafe(password); CFReleaseSafe(salt); CFReleaseSafe(passwordData); CFReleaseSafe(saltData); CFReleaseSafe(resultData); } { CFStringRef password = CFStringCreateWithCString(NULL, "password", kCFStringEncodingUTF8); CFStringRef salt = CFStringCreateWithCString(NULL, "salt", kCFStringEncodingUTF8); CFDataRef passwordData = CFStringCreateExternalRepresentation(NULL, password, kCFStringEncodingUTF8, 0); CFDataRef saltData = CFStringCreateExternalRepresentation(NULL, salt, kCFStringEncodingUTF8, 0); const int iterations = 2; const uint8_t expected[20] = { 0xea, 0x6c, 0x01, 0x4d, 0xc7, 0x2d, 0x6f, 0x8c, 0xcd, 0x1e, 0xd9, 0x2a, 0xce, 0x1d, 0x41, 0xf0, 0xd8, 0xde, 0x89, 0x57 }; const char resultSize = sizeof(expected); CFMutableDataRef resultData = CFDataCreateMutable(NULL, resultSize); CFDataIncreaseLength(resultData, resultSize); SecKeyFromPassphraseDataHMACSHA1(passwordData, saltData, iterations, resultData); ok(memcmp(expected, CFDataGetBytePtr(resultData), resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1"); CFReleaseSafe(password); CFReleaseSafe(salt); CFReleaseSafe(passwordData); CFReleaseSafe(saltData); CFReleaseSafe(resultData); } { CFStringRef password = CFStringCreateWithCString(NULL, "password", kCFStringEncodingUTF8); CFStringRef salt = CFStringCreateWithCString(NULL, "salt", kCFStringEncodingUTF8); CFDataRef passwordData = CFStringCreateExternalRepresentation(NULL, password, kCFStringEncodingUTF8, 0); CFDataRef saltData = CFStringCreateExternalRepresentation(NULL, salt, kCFStringEncodingUTF8, 0); const int iterations = 4096; const uint8_t expected[20] = { 0x4b, 0x00, 0x79, 0x01, 0xb7, 0x65, 0x48, 0x9a, 0xbe, 0xad, 0x49, 0xd9, 0x26, 0xf7, 0x21, 0xd0, 0x65, 0xa4, 0x29, 0xc1 }; const char resultSize = sizeof(expected); CFMutableDataRef resultData = CFDataCreateMutable(NULL, resultSize); CFDataIncreaseLength(resultData, resultSize); SecKeyFromPassphraseDataHMACSHA1(passwordData, saltData, iterations, resultData); ok(memcmp(expected, CFDataGetBytePtr(resultData), resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1"); CFReleaseSafe(password); CFReleaseSafe(salt); CFReleaseSafe(passwordData); CFReleaseSafe(saltData); CFReleaseSafe(resultData); } SKIP: { skip("16777216 iterations is too slow", 1, 0); CFStringRef password = CFStringCreateWithCString(NULL, "password", kCFStringEncodingUTF8); CFStringRef salt = CFStringCreateWithCString(NULL, "salt", kCFStringEncodingUTF8); CFDataRef passwordData = CFStringCreateExternalRepresentation(NULL, password, kCFStringEncodingUTF8, 0); CFDataRef saltData = CFStringCreateExternalRepresentation(NULL, salt, kCFStringEncodingUTF8, 0); const int iterations = 16777216; const uint8_t expected[20] = { 0xee, 0xfe, 0x3d, 0x61, 0xcd, 0x4d, 0xa4, 0xe4, 0xe9, 0x94, 0x5b, 0x3d, 0x6b, 0xa2, 0x15, 0x8c, 0x26, 0x34, 0xe9, 0x84 }; const char resultSize = sizeof(expected); CFMutableDataRef resultData = CFDataCreateMutable(NULL, resultSize); CFDataIncreaseLength(resultData, resultSize); SecKeyFromPassphraseDataHMACSHA1(passwordData, saltData, iterations, resultData); ok(memcmp(expected, CFDataGetBytePtr(resultData), resultSize) == 0, "pbkdf-sha-1: P-'password' S-'Salt' I-1"); CFReleaseSafe(password); CFReleaseSafe(salt); CFReleaseSafe(passwordData); CFReleaseSafe(saltData); CFReleaseSafe(resultData); } }
static void test_profile_items(void) { char path[MAX_PATH], commonprogs[MAX_PATH]; HMODULE hShell32; BOOL (WINAPI *pSHGetFolderPathA)(HWND hwnd, int nFolder, HANDLE hToken, DWORD dwFlags, LPSTR pszPath); static const char *inf = "[Version]\n" "Signature=\"$Chicago$\"\n" "[DefaultInstall]\n" "ProfileItems=TestItem,TestItem2,TestGroup\n" "[TestItem]\n" "Name=TestItem\n" "CmdLine=11,,notepad.exe\n" "[TestItem2]\n" "Name=TestItem2\n" "CmdLine=11,,notepad.exe\n" "SubDir=TestDir\n" "[TestGroup]\n" "Name=TestGroup,4\n" ; hShell32 = LoadLibraryA("shell32"); pSHGetFolderPathA = (void*)GetProcAddress(hShell32, "SHGetFolderPathA"); if (!pSHGetFolderPathA) { win_skip("SHGetFolderPathA is not available\n"); goto cleanup; } if (S_OK != pSHGetFolderPathA(NULL, CSIDL_COMMON_PROGRAMS, NULL, SHGFP_TYPE_CURRENT, commonprogs)) { skip("No common program files directory exists\n"); goto cleanup; } create_inf_file(inffile, inf); sprintf(path, "%s\\%s", CURR_DIR, inffile); run_cmdline("DefaultInstall", 128, path); snprintf(path, MAX_PATH, "%s\\TestItem.lnk", commonprogs); if (INVALID_FILE_ATTRIBUTES == GetFileAttributesA(path)) { win_skip("ProfileItems not implemented on this system\n"); } else { snprintf(path, MAX_PATH, "%s\\TestDir", commonprogs); ok(INVALID_FILE_ATTRIBUTES != GetFileAttributesA(path), "directory not created\n"); snprintf(path, MAX_PATH, "%s\\TestDir\\TestItem2.lnk", commonprogs); ok(INVALID_FILE_ATTRIBUTES != GetFileAttributesA(path), "link not created\n"); snprintf(path, MAX_PATH, "%s\\TestGroup", commonprogs); ok(INVALID_FILE_ATTRIBUTES != GetFileAttributesA(path), "group not created\n"); } snprintf(path, MAX_PATH, "%s\\TestItem.lnk", commonprogs); DeleteFileA(path); snprintf(path, MAX_PATH, "%s\\TestDir\\TestItem2.lnk", commonprogs); DeleteFileA(path); snprintf(path, MAX_PATH, "%s\\TestItem2.lnk", commonprogs); DeleteFileA(path); snprintf(path, MAX_PATH, "%s\\TestDir", commonprogs); RemoveDirectoryA(path); snprintf(path, MAX_PATH, "%s\\TestGroup", commonprogs); RemoveDirectoryA(path); cleanup: if (hShell32) FreeLibrary(hShell32); DeleteFileA(inffile); }
static void test_GetFileVersionInfoEx(void) { char *ver, *p; BOOL ret; UINT size, translation, i; HMODULE mod; BOOL (WINAPI *pGetFileVersionInfoExW)(DWORD, LPCWSTR, DWORD, DWORD, LPVOID); DWORD (WINAPI *pGetFileVersionInfoSizeExW)(DWORD, LPCWSTR, LPDWORD); const LANGID lang = GetUserDefaultUILanguage(); const LANGID english = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT); const WORD unicode = 1200; /* = UNICODE */ const WCHAR kernel32W[] = {'k','e','r','n','e','l','3','2','.','d','l','l',0}; const DWORD test_flags[] = { 0, FILE_VER_GET_LOCALISED, FILE_VER_GET_NEUTRAL, FILE_VER_GET_LOCALISED | FILE_VER_GET_NEUTRAL, 0xdeadbeef, /* invalid value (ignored) */ }; char desc[MAX_PATH]; mod = GetModuleHandleA("kernel32.dll"); assert(mod); if (!FindResourceExA(mod, (LPCSTR)RT_VERSION, (LPCSTR)VS_VERSION_INFO, lang) && !FindResourceExA(mod, (LPCSTR)RT_VERSION, (LPCSTR)VS_VERSION_INFO, MAKELANGID(PRIMARYLANGID(lang),SUBLANG_NEUTRAL))) { skip("Translation is not available\n"); return; } size = GetFileVersionInfoSizeW(kernel32W, NULL); ok(size, "GetFileVersionInfoSize(kernel32) error %u\n", GetLastError()); ver = HeapAlloc(GetProcessHeap(), 0, size); assert(ver); ret = GetFileVersionInfoW(kernel32W, 0, size, ver); ok(ret, "GetFileVersionInfo error %u\n", GetLastError()); ret = VerQueryValueA(ver, "\\VarFileInfo\\Translation", (void **)&p, &size); translation = *(UINT *)p; ok(ret, "VerQueryValue error %u\n", GetLastError()); ok(size == 4, "VerQueryValue returned %u, expected 4\n", size); /* test default version resource */ ok(LOWORD(translation) == lang, "got %u, expected lang is %u\n", LOWORD(translation), lang); ok(HIWORD(translation) == unicode, "got %u, expected codepage is %u\n", HIWORD(translation), unicode); HeapFree(GetProcessHeap(), 0, ver); mod = GetModuleHandleA("version.dll"); assert(mod); /* prefer W-version as A-version is not available on Windows 7 */ pGetFileVersionInfoExW = (void *)GetProcAddress(mod, "GetFileVersionInfoExW"); pGetFileVersionInfoSizeExW = (void *)GetProcAddress(mod, "GetFileVersionInfoSizeExW"); if (!pGetFileVersionInfoExW && !pGetFileVersionInfoSizeExW) { win_skip("GetFileVersionInfoEx family is not available\n"); return; } for (i = 0; i < ARRAY_SIZE(test_flags); i++) { size = pGetFileVersionInfoSizeExW(test_flags[i], kernel32W, NULL); ok(size, "[%u] GetFileVersionInfoSizeEx(kernel32) error %u\n", i, GetLastError()); ver = HeapAlloc(GetProcessHeap(), 0, size); assert(ver); ret = pGetFileVersionInfoExW(test_flags[i], kernel32W, 0, size, ver); ok(ret, "[%u] GetFileVersionInfoEx error %u\n", i, GetLastError()); ret = VerQueryValueA(ver, "\\VarFileInfo\\Translation", (void **)&p, &size); ok(ret, "[%u] VerQueryValue error %u\n", i, GetLastError()); ok(size == 4, "[%u] VerQueryValue returned %u, expected 4\n", i, size); translation = *(UINT *)p; /* test MUI version resource */ if (test_flags[i] & FILE_VER_GET_LOCALISED) ok(LOWORD(translation) == lang, "[%u] got %u, expected lang is %u\n", i, LOWORD(translation), lang); else ok(LOWORD(translation) == english, "[%u] got %u, expected lang is %u\n", i, LOWORD(translation), english); ok(HIWORD(translation) == unicode, "[%u] got %u, expected codepage is %u\n", i, HIWORD(translation), unicode); /* test string info using translation info */ size = 0; sprintf(desc, "\\StringFileInfo\\%04x%04x\\FileDescription", LOWORD(translation), HIWORD(translation)); ret = VerQueryValueA(ver, desc, (void **)&p, &size); ok(ret, "[%u] VerQueryValue error %u\n", i, GetLastError()); ok(size == strlen(p) + 1, "[%u] VerQueryValue returned %u\n", i, size); HeapFree(GetProcessHeap(), 0, ver); } return; }
static void test_mmioOpen(char *fname) { char buf[MMIO_DEFAULTBUFFER]; MMRESULT ret; HMMIO hmmio; MMIOINFO mmio; memset(&mmio, 0, sizeof(mmio)); mmio.fccIOProc = fname ? FOURCC_DOS : FOURCC_MEM; mmio.cchBuffer = sizeof(buf); mmio.pchBuffer = buf; hmmio = mmioOpen(fname, &mmio, MMIO_READ); if (fname && !hmmio) { trace("No optional %s file. Skipping the test\n", fname); return; } ok(hmmio != 0, "mmioOpen error %u\n", mmio.wErrorRet); memset(&mmio, 0, sizeof(mmio)); ret = mmioGetInfo(hmmio, &mmio, 0); ok(ret == MMSYSERR_NOERROR, "mmioGetInfo error %u\n", ret); ok(mmio.dwFlags == MMIO_READ, "expected MMIO_READ, got %x\n", mmio.dwFlags); ok(mmio.wErrorRet == MMSYSERR_NOERROR, "expected MMSYSERR_NOERROR, got %u\n", mmio.wErrorRet); ok(mmio.fccIOProc == (fname ? FOURCC_DOS : FOURCC_MEM), "got %4.4s\n", (LPCSTR)&mmio.fccIOProc); ok(mmio.cchBuffer == sizeof(buf), "got %u\n", mmio.cchBuffer); ok(mmio.pchBuffer == buf, "expected %p, got %p\n", buf, mmio.pchBuffer); ok(mmio.pchNext == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchNext); if (mmio.fccIOProc == FOURCC_DOS) ok(mmio.pchEndRead == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchEndRead); else ok(mmio.pchEndRead == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndRead); ok(mmio.pchEndWrite == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndWrite); ok(mmio.lBufOffset == 0, "expected 0, got %d\n", mmio.lBufOffset); ok(mmio.lDiskOffset == 0, "expected 0, got %d\n", mmio.lDiskOffset); ret = mmioSeek(hmmio, 0, SEEK_CUR); ok(ret == 0, "expected 0, got %d\n", ret); mmioClose(hmmio, 0); memset(&mmio, 0, sizeof(mmio)); mmio.fccIOProc = fname ? FOURCC_DOS : FOURCC_MEM; mmio.cchBuffer = 0; mmio.pchBuffer = buf; hmmio = mmioOpen(fname, &mmio, MMIO_READ); ok(hmmio != 0, "mmioOpen error %u\n", mmio.wErrorRet); memset(&mmio, 0, sizeof(mmio)); ret = mmioGetInfo(hmmio, &mmio, 0); ok(ret == MMSYSERR_NOERROR, "mmioGetInfo error %u\n", ret); ok(mmio.dwFlags == MMIO_READ, "expected MMIO_READ, got %x\n", mmio.dwFlags); ok(mmio.wErrorRet == MMSYSERR_NOERROR, "expected MMSYSERR_NOERROR, got %u\n", mmio.wErrorRet); ok(mmio.fccIOProc == (fname ? FOURCC_DOS : FOURCC_MEM), "got %4.4s\n", (LPCSTR)&mmio.fccIOProc); ok(mmio.cchBuffer == 0, "expected 0, got %u\n", mmio.cchBuffer); ok(mmio.pchBuffer == buf, "expected %p, got %p\n", buf, mmio.pchBuffer); ok(mmio.pchNext == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchNext); ok(mmio.pchEndRead == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchEndRead); ok(mmio.pchEndWrite == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchEndWrite); ok(mmio.lBufOffset == 0, "expected 0, got %d\n", mmio.lBufOffset); ok(mmio.lDiskOffset == 0, "expected 0, got %d\n", mmio.lDiskOffset); ret = mmioSeek(hmmio, 0, SEEK_CUR); ok(ret == 0, "expected 0, got %d\n", ret); mmioClose(hmmio, 0); memset(&mmio, 0, sizeof(mmio)); mmio.fccIOProc = fname ? FOURCC_DOS : FOURCC_MEM; mmio.cchBuffer = 0; mmio.pchBuffer = NULL; hmmio = mmioOpen(fname, &mmio, MMIO_READ); ok(hmmio != 0, "mmioOpen error %u\n", mmio.wErrorRet); memset(&mmio, 0, sizeof(mmio)); ret = mmioGetInfo(hmmio, &mmio, 0); ok(ret == MMSYSERR_NOERROR, "mmioGetInfo error %u\n", ret); ok(mmio.dwFlags == MMIO_READ, "expected MMIO_READ, got %x\n", mmio.dwFlags); ok(mmio.wErrorRet == MMSYSERR_NOERROR, "expected MMSYSERR_NOERROR, got %u\n", mmio.wErrorRet); ok(mmio.fccIOProc == (fname ? FOURCC_DOS : FOURCC_MEM), "got %4.4s\n", (LPCSTR)&mmio.fccIOProc); ok(mmio.cchBuffer == 0, "expected 0, got %u\n", mmio.cchBuffer); ok(mmio.pchBuffer == NULL, "expected NULL\n"); ok(mmio.pchNext == NULL, "expected NULL\n"); ok(mmio.pchEndRead == NULL, "expected NULL\n"); ok(mmio.pchEndWrite == NULL, "expected NULL\n"); ok(mmio.lBufOffset == 0, "expected 0, got %d\n", mmio.lBufOffset); ok(mmio.lDiskOffset == 0, "expected 0, got %d\n", mmio.lDiskOffset); #if 0 /* remove once passes under Wine */ ret = mmioSeek(hmmio, 0, SEEK_CUR); ok(ret == 0, "expected 0, got %d\n", ret); #endif mmioClose(hmmio, 0); memset(&mmio, 0, sizeof(mmio)); mmio.fccIOProc = fname ? FOURCC_DOS : FOURCC_MEM; mmio.cchBuffer = 256; mmio.pchBuffer = NULL; hmmio = mmioOpen(fname, &mmio, MMIO_READ); ok(hmmio != 0, "mmioOpen error %u\n", mmio.wErrorRet); memset(&mmio, 0, sizeof(mmio)); ret = mmioGetInfo(hmmio, &mmio, 0); ok(ret == MMSYSERR_NOERROR, "mmioGetInfo error %u\n", ret); ok(mmio.dwFlags == (MMIO_READ|MMIO_ALLOCBUF), "expected MMIO_READ|MMIO_ALLOCBUF, got %x\n", mmio.dwFlags); ok(mmio.wErrorRet == MMSYSERR_NOERROR, "expected MMSYSERR_NOERROR, got %u\n", mmio.wErrorRet); ok(mmio.fccIOProc == (fname ? FOURCC_DOS : FOURCC_MEM), "got %4.4s\n", (LPCSTR)&mmio.fccIOProc); ok(mmio.cchBuffer == 256, "expected 256, got %u\n", mmio.cchBuffer); ok(mmio.pchBuffer != NULL, "expected not NULL\n"); ok(mmio.pchNext == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchNext); if (mmio.fccIOProc == FOURCC_DOS) ok(mmio.pchEndRead == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchEndRead); else ok(mmio.pchEndRead == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndRead); ok(mmio.pchEndWrite == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndWrite); ok(mmio.lBufOffset == 0, "expected 0, got %d\n", mmio.lBufOffset); ok(mmio.lDiskOffset == 0, "expected 0, got %d\n", mmio.lDiskOffset); #if 0 /* remove once passes under Wine */ ret = mmioSeek(hmmio, 0, SEEK_CUR); ok(ret == 0, "expected 0, got %d\n", ret); #endif mmioClose(hmmio, 0); memset(&mmio, 0, sizeof(mmio)); mmio.fccIOProc = fname ? FOURCC_DOS : FOURCC_MEM; mmio.cchBuffer = sizeof(buf); mmio.pchBuffer = buf; hmmio = mmioOpen(fname, &mmio, MMIO_READ | MMIO_ALLOCBUF); ok(hmmio != 0, "mmioOpen error %u\n", mmio.wErrorRet); memset(&mmio, 0, sizeof(mmio)); ret = mmioGetInfo(hmmio, &mmio, 0); ok(ret == MMSYSERR_NOERROR, "mmioGetInfo error %u\n", ret); ok(mmio.dwFlags == MMIO_READ, "expected MMIO_READ, got %x\n", mmio.dwFlags); ok(mmio.wErrorRet == MMSYSERR_NOERROR, "expected MMSYSERR_NOERROR, got %u\n", mmio.wErrorRet); ok(mmio.fccIOProc == (fname ? FOURCC_DOS : FOURCC_MEM), "got %4.4s\n", (LPCSTR)&mmio.fccIOProc); ok(mmio.cchBuffer == sizeof(buf), "got %u\n", mmio.cchBuffer); ok(mmio.pchBuffer == buf, "expected %p, got %p\n", buf, mmio.pchBuffer); ok(mmio.pchNext == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchNext); if (mmio.fccIOProc == FOURCC_DOS) ok(mmio.pchEndRead == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchEndRead); else ok(mmio.pchEndRead == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndRead); ok(mmio.pchEndWrite == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndWrite); ok(mmio.lBufOffset == 0, "expected 0, got %d\n", mmio.lBufOffset); ok(mmio.lDiskOffset == 0, "expected 0, got %d\n", mmio.lDiskOffset); ret = mmioSeek(hmmio, 0, SEEK_CUR); ok(ret == 0, "expected 0, got %d\n", ret); mmioClose(hmmio, 0); memset(&mmio, 0, sizeof(mmio)); mmio.fccIOProc = fname ? FOURCC_DOS : FOURCC_MEM; mmio.cchBuffer = 0; mmio.pchBuffer = NULL; hmmio = mmioOpen(fname, &mmio, MMIO_READ | MMIO_ALLOCBUF); ok(hmmio != 0, "mmioOpen error %u\n", mmio.wErrorRet); memset(&mmio, 0, sizeof(mmio)); ret = mmioGetInfo(hmmio, &mmio, 0); ok(ret == MMSYSERR_NOERROR, "mmioGetInfo error %u\n", ret); ok(mmio.dwFlags == (MMIO_READ|MMIO_ALLOCBUF), "expected MMIO_READ|MMIO_ALLOCBUF, got %x\n", mmio.dwFlags); ok(mmio.wErrorRet == MMSYSERR_NOERROR, "expected MMSYSERR_NOERROR, got %u\n", mmio.wErrorRet); ok(mmio.fccIOProc == (fname ? FOURCC_DOS : FOURCC_MEM), "got %4.4s\n", (LPCSTR)&mmio.fccIOProc); ok(mmio.cchBuffer == MMIO_DEFAULTBUFFER, "expected MMIO_DEFAULTBUFFER, got %u\n", mmio.cchBuffer); ok(mmio.pchBuffer != NULL, "expected not NULL\n"); ok(mmio.pchNext == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchNext); if (mmio.fccIOProc == FOURCC_DOS) ok(mmio.pchEndRead == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchEndRead); else ok(mmio.pchEndRead == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndRead); ok(mmio.pchEndWrite == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndWrite); ok(mmio.lBufOffset == 0, "expected 0, got %d\n", mmio.lBufOffset); ok(mmio.lDiskOffset == 0, "expected 0, got %d\n", mmio.lDiskOffset); #if 0 /* remove once passes under Wine */ ret = mmioSeek(hmmio, 0, SEEK_CUR); ok(ret == 0, "expected 0, got %d\n", ret); #endif mmioClose(hmmio, 0); memset(&mmio, 0, sizeof(mmio)); mmio.fccIOProc = fname ? FOURCC_DOS : FOURCC_MEM; mmio.cchBuffer = 256; mmio.pchBuffer = NULL; hmmio = mmioOpen(fname, &mmio, MMIO_READ | MMIO_ALLOCBUF); ok(hmmio != 0, "mmioOpen error %u\n", mmio.wErrorRet); memset(&mmio, 0, sizeof(mmio)); ret = mmioGetInfo(hmmio, &mmio, 0); ok(ret == MMSYSERR_NOERROR, "mmioGetInfo error %u\n", ret); ok(mmio.dwFlags == (MMIO_READ|MMIO_ALLOCBUF), "expected MMIO_READ|MMIO_ALLOCBUF, got %x\n", mmio.dwFlags); ok(mmio.wErrorRet == MMSYSERR_NOERROR, "expected MMSYSERR_NOERROR, got %u\n", mmio.wErrorRet); ok(mmio.fccIOProc == (fname ? FOURCC_DOS : FOURCC_MEM), "got %4.4s\n", (LPCSTR)&mmio.fccIOProc); ok(mmio.cchBuffer == 256, "expected 256, got %u\n", mmio.cchBuffer); ok(mmio.pchBuffer != NULL, "expected not NULL\n"); ok(mmio.pchNext == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchNext); if (mmio.fccIOProc == FOURCC_DOS) ok(mmio.pchEndRead == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchEndRead); else ok(mmio.pchEndRead == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndRead); ok(mmio.pchEndWrite == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndWrite); ok(mmio.lBufOffset == 0, "expected 0, got %d\n", mmio.lBufOffset); ok(mmio.lDiskOffset == 0, "expected 0, got %d\n", mmio.lDiskOffset); #if 0 /* remove once passes under Wine */ ret = mmioSeek(hmmio, 0, SEEK_CUR); ok(ret == 0, "expected 0, got %d\n", ret); #endif mmioClose(hmmio, 0); memset(&mmio, 0, sizeof(mmio)); mmio.fccIOProc = fname ? FOURCC_DOS : FOURCC_MEM; mmio.cchBuffer = 0; mmio.pchBuffer = buf; hmmio = mmioOpen(fname, &mmio, MMIO_READ | MMIO_ALLOCBUF); if (!hmmio && mmio.wErrorRet == ERROR_BAD_FORMAT) { /* Seen on Win9x, WinMe but also XP-SP1 */ skip("Some Windows versions don't like a 0 size and a given buffer\n"); return; } ok(hmmio != 0, "mmioOpen error %u\n", mmio.wErrorRet); memset(&mmio, 0, sizeof(mmio)); ret = mmioGetInfo(hmmio, &mmio, 0); ok(ret == MMSYSERR_NOERROR, "mmioGetInfo error %u\n", ret); ok(mmio.dwFlags == MMIO_READ, "expected MMIO_READ, got %x\n", mmio.dwFlags); ok(mmio.wErrorRet == MMSYSERR_NOERROR, "expected MMSYSERR_NOERROR, got %u\n", mmio.wErrorRet); ok(mmio.fccIOProc == (fname ? FOURCC_DOS : FOURCC_MEM), "got %4.4s\n", (LPCSTR)&mmio.fccIOProc); ok(mmio.cchBuffer == MMIO_DEFAULTBUFFER, "expected MMIO_DEFAULTBUFFER, got %u\n", mmio.cchBuffer); ok(mmio.pchBuffer == buf, "expected %p, got %p\n", buf, mmio.pchBuffer); ok(mmio.pchNext == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchNext); if (mmio.fccIOProc == FOURCC_DOS) ok(mmio.pchEndRead == mmio.pchBuffer, "expected %p, got %p\n", mmio.pchBuffer, mmio.pchEndRead); else ok(mmio.pchEndRead == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndRead); ok(mmio.pchEndWrite == mmio.pchBuffer + mmio.cchBuffer, "expected %p + %d, got %p\n", mmio.pchBuffer, mmio.cchBuffer, mmio.pchEndWrite); ok(mmio.lBufOffset == 0, "expected 0, got %d\n", mmio.lBufOffset); ok(mmio.lDiskOffset == 0, "expected 0, got %d\n", mmio.lDiskOffset); ret = mmioSeek(hmmio, 0, SEEK_CUR); ok(ret == 0, "expected 0, got %d\n", ret); mmioClose(hmmio, 0); }
static void test_aggregation(const CLSID clsidOuter, const CLSID clsidInner, const IID iidOuter, const IID iidInner) { HRESULT hr; ULONG refCount; IUnknown *pUnkOuter = NULL; IUnknown *pUnkInner = NULL; IUnknown *pUnkInnerFail = NULL; IUnknown *pUnkOuterTest = NULL; IUnknown *pUnkInnerTest = NULL; IUnknown *pUnkAggregatee = NULL; IUnknown *pUnkAggregator = NULL; IUnknown *pUnkTest = NULL; hr = CoCreateInstance(&clsidOuter, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (LPVOID*)&pUnkOuter); ok(hr == S_OK, "CoCreateInstance failed with %x\n", hr); ok(pUnkOuter != NULL, "pUnkOuter is NULL\n"); if (!pUnkOuter) { skip("pUnkOuter is NULL\n"); return; } /* for aggregation, we should only be able to request IUnknown */ hr = CoCreateInstance(&clsidInner, pUnkOuter, CLSCTX_INPROC_SERVER, &iidInner, (LPVOID*)&pUnkInnerFail); if (hr == REGDB_E_CLASSNOTREG) { skip("Class not registered\n"); return; } ok(hr == E_NOINTERFACE, "CoCreateInstance returned %x\n", hr); ok(pUnkInnerFail == NULL, "pUnkInnerFail is not NULL\n"); /* aggregation, request IUnknown */ hr = CoCreateInstance(&clsidInner, pUnkOuter, CLSCTX_INPROC_SERVER, &IID_IUnknown, (LPVOID*)&pUnkInner); ok(hr == S_OK, "CoCreateInstance returned %x\n", hr); ok(pUnkInner != NULL, "pUnkInner is NULL\n"); if (!pUnkInner) { skip("pUnkInner is NULL\n"); return; } ADDREF_EXPECT(pUnkOuter, 2); ADDREF_EXPECT(pUnkInner, 2); RELEASE_EXPECT(pUnkOuter, 1); RELEASE_EXPECT(pUnkInner, 1); QI_FAIL(pUnkOuter, iidInner, pUnkAggregatee); QI_FAIL(pUnkInner, iidOuter, pUnkAggregator); /* these QueryInterface calls should work */ QI_SUCCEED(pUnkOuter, iidOuter, pUnkAggregator); QI_SUCCEED(pUnkOuter, IID_IUnknown, pUnkOuterTest); /* IGraphConfig interface comes with DirectShow 9 */ if(IsEqualGUID(&IID_IGraphConfig, &iidInner)) { hr = IUnknown_QueryInterface(pUnkInner, &iidInner, (LPVOID*)&pUnkAggregatee); ok(hr == S_OK || broken(hr == E_NOINTERFACE), "IUnknown_QueryInterface returned %x\n", hr); ok(pUnkAggregatee != NULL || broken(!pUnkAggregatee), "Pointer is NULL\n"); } else { QI_SUCCEED(pUnkInner, iidInner, pUnkAggregatee); } QI_SUCCEED(pUnkInner, IID_IUnknown, pUnkInnerTest); if (!pUnkAggregator || !pUnkOuterTest || !pUnkAggregatee || !pUnkInnerTest) { skip("One of the required interfaces is NULL\n"); return; } ADDREF_EXPECT(pUnkAggregator, 5); ADDREF_EXPECT(pUnkOuterTest, 6); ADDREF_EXPECT(pUnkAggregatee, 7); ADDREF_EXPECT(pUnkInnerTest, 3); RELEASE_EXPECT(pUnkAggregator, 6); RELEASE_EXPECT(pUnkOuterTest, 5); RELEASE_EXPECT(pUnkAggregatee, 4); RELEASE_EXPECT(pUnkInnerTest, 2); QI_SUCCEED(pUnkAggregator, IID_IUnknown, pUnkTest); QI_SUCCEED(pUnkOuterTest, IID_IUnknown, pUnkTest); QI_SUCCEED(pUnkAggregatee, IID_IUnknown, pUnkTest); QI_SUCCEED(pUnkInnerTest, IID_IUnknown, pUnkTest); QI_FAIL(pUnkAggregator, iidInner, pUnkTest); QI_FAIL(pUnkOuterTest, iidInner, pUnkTest); QI_FAIL(pUnkAggregatee, iidInner, pUnkTest); QI_SUCCEED(pUnkInnerTest, iidInner, pUnkTest); QI_SUCCEED(pUnkAggregator, iidOuter, pUnkTest); QI_SUCCEED(pUnkOuterTest, iidOuter, pUnkTest); QI_SUCCEED(pUnkAggregatee, iidOuter, pUnkTest); QI_FAIL(pUnkInnerTest, iidOuter, pUnkTest); RELEASE_EXPECT(pUnkAggregator, 10); RELEASE_EXPECT(pUnkOuterTest, 9); RELEASE_EXPECT(pUnkAggregatee, 8); RELEASE_EXPECT(pUnkInnerTest, 2); RELEASE_EXPECT(pUnkOuter, 7); RELEASE_EXPECT(pUnkInner, 1); do { refCount = IUnknown_Release(pUnkInner); } while (refCount); do { refCount = IUnknown_Release(pUnkOuter); } while (refCount); }
static void test_legacy_filter_registration(void) { IFilterMapper2 *pMapper2 = NULL; IFilterMapper *pMapper = NULL; HRESULT hr; static const WCHAR wszFilterName[] = {'T', 'e', 's', 't', 'f', 'i', 'l', 't', 'e', 'r', 0 }; static const CHAR szFilterName[] = "Testfilter"; static const WCHAR wszPinName[] = {'P', 'i', 'n', '1', 0 }; CLSID clsidFilter; CHAR szRegKey[MAX_PATH]; static const CHAR szClsid[] = "CLSID"; WCHAR wszGuidstring[MAX_PATH]; CHAR szGuidstring[MAX_PATH]; LONG lRet; HKEY hKey = NULL; IEnumMoniker *pEnum = NULL; BOOL found; IEnumRegFilters *pRegEnum = NULL; /* Test if legacy filter registration scheme works (filter is added to HKCR\Filter). IFilterMapper_RegisterFilter * registers in this way. Filters so registered must then be accessible through both IFilterMapper_EnumMatchingFilters * and IFilterMapper2_EnumMatchingFilters. */ hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&pMapper2); ok(hr == S_OK, "CoCreateInstance failed with %x\n", hr); if (FAILED(hr)) goto out; hr = IFilterMapper2_QueryInterface(pMapper2, &IID_IFilterMapper, (void **)&pMapper); ok(hr == S_OK, "IFilterMapper2_QueryInterface failed with %x\n", hr); if (FAILED(hr)) goto out; /* Register a test filter. */ hr = CoCreateGuid(&clsidFilter); ok(hr == S_OK, "CoCreateGuid failed with %x\n", hr); lRet = StringFromGUID2(&clsidFilter, wszGuidstring, MAX_PATH); ok(lRet > 0, "StringFromGUID2 failed\n"); if (!lRet) goto out; WideCharToMultiByte(CP_ACP, 0, wszGuidstring, -1, szGuidstring, MAX_PATH, 0, 0); lstrcpyA(szRegKey, szClsid); lstrcatA(szRegKey, "\\"); lstrcatA(szRegKey, szGuidstring); /* Register---- functions need a filter class key to write pin and pin media type data to. Create a bogus * class key for it. */ lRet = RegCreateKeyExA(HKEY_CLASSES_ROOT, szRegKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL); if (lRet == ERROR_ACCESS_DENIED) skip("Not authorized to register filters\n"); else { ok(lRet == ERROR_SUCCESS, "RegCreateKeyExA failed with %x\n", HRESULT_FROM_WIN32(lRet)); /* Set default value - this is interpreted as "friendly name" later. */ lRet = RegSetValueExA(hKey, NULL, 0, REG_SZ, (LPBYTE)szFilterName, lstrlenA(szFilterName) + 1); ok(lRet == ERROR_SUCCESS, "RegSetValueExA failed with %x\n", HRESULT_FROM_WIN32(lRet)); if (hKey) RegCloseKey(hKey); hKey = NULL; hr = IFilterMapper_RegisterFilter(pMapper, clsidFilter, wszFilterName, MERIT_UNLIKELY); ok(hr == S_OK, "IFilterMapper_RegisterFilter failed with %x\n", hr); hr = IFilterMapper_RegisterPin(pMapper, clsidFilter, wszPinName, TRUE, FALSE, FALSE, FALSE, GUID_NULL, NULL); ok(hr == S_OK, "IFilterMapper_RegisterPin failed with %x\n", hr); hr = IFilterMapper_RegisterPinType(pMapper, clsidFilter, wszPinName, GUID_NULL, GUID_NULL); ok(hr == S_OK, "IFilterMapper_RegisterPinType failed with %x\n", hr); hr = IFilterMapper2_EnumMatchingFilters(pMapper2, &pEnum, 0, TRUE, MERIT_UNLIKELY, TRUE, 0, NULL, NULL, &GUID_NULL, FALSE, FALSE, 0, NULL, NULL, &GUID_NULL); ok(hr == S_OK, "IFilterMapper2_EnumMatchingFilters failed with %x\n", hr); if (SUCCEEDED(hr) && pEnum) { found = enum_find_filter(wszFilterName, pEnum); ok(found, "IFilterMapper2_EnumMatchingFilters failed to return the test filter\n"); } if (pEnum) IEnumMoniker_Release(pEnum); pEnum = NULL; found = FALSE; hr = IFilterMapper_EnumMatchingFilters(pMapper, &pRegEnum, MERIT_UNLIKELY, TRUE, GUID_NULL, GUID_NULL, FALSE, FALSE, GUID_NULL, GUID_NULL); ok(hr == S_OK, "IFilterMapper_EnumMatchingFilters failed with %x\n", hr); if (SUCCEEDED(hr) && pRegEnum) { ULONG cFetched; REGFILTER *prgf; while(!found && IEnumRegFilters_Next(pRegEnum, 1, &prgf, &cFetched) == S_OK) { CHAR val[512]; WideCharToMultiByte(CP_ACP, 0, prgf->Name, -1, val, sizeof(val), 0, 0); if (!lstrcmpA(val, szFilterName)) found = TRUE; CoTaskMemFree(prgf); } IEnumRegFilters_Release(pRegEnum); } ok(found, "IFilterMapper_EnumMatchingFilters failed to return the test filter\n"); hr = IFilterMapper_UnregisterFilter(pMapper, clsidFilter); ok(hr == S_OK, "FilterMapper_UnregisterFilter failed with %x\n", hr); lRet = RegOpenKeyExA(HKEY_CLASSES_ROOT, szClsid, 0, KEY_WRITE | DELETE, &hKey); ok(lRet == ERROR_SUCCESS, "RegOpenKeyExA failed with %x\n", HRESULT_FROM_WIN32(lRet)); lRet = RegDeleteKeyA(hKey, szGuidstring); ok(lRet == ERROR_SUCCESS, "RegDeleteKeyA failed with %x\n", HRESULT_FROM_WIN32(lRet)); } if (hKey) RegCloseKey(hKey); hKey = NULL; out: if (pMapper) IFilterMapper_Release(pMapper); if (pMapper2) IFilterMapper2_Release(pMapper2); }
static bool s5p_jpeg_parse_hdr(struct s5p_jpeg_q_data *result, unsigned long buffer, unsigned long size) { int c, components, notfound; unsigned int height, width, word; long length; struct s5p_jpeg_buffer jpeg_buffer; jpeg_buffer.size = size; jpeg_buffer.data = buffer; jpeg_buffer.curr = 0; notfound = 1; while (notfound) { c = get_byte(&jpeg_buffer); if (c == -1) break; if (c != 0xff) continue; do c = get_byte(&jpeg_buffer); while (c == 0xff); if (c == -1) break; if (c == 0) continue; length = 0; switch (c) { /* SOF0: baseline JPEG */ case SOF0: if (get_word_be(&jpeg_buffer, &word)) break; if (get_byte(&jpeg_buffer) == -1) break; if (get_word_be(&jpeg_buffer, &height)) break; if (get_word_be(&jpeg_buffer, &width)) break; components = get_byte(&jpeg_buffer); if (components == -1) break; notfound = 0; skip(&jpeg_buffer, components * 3); break; /* skip payload-less markers */ case RST ... RST + 7: case SOI: case EOI: case TEM: break; /* skip uninteresting payload markers */ default: if (get_word_be(&jpeg_buffer, &word)) break; length = (long)word - 2; skip(&jpeg_buffer, length); break; } } result->w = width; result->h = height; result->size = components; return !notfound; }
static void test_register_filter_with_null_clsMinorType(void) { IFilterMapper2 *pMapper = NULL; HRESULT hr; REGFILTER2 rgf2; REGFILTERPINS rgPins; REGFILTERPINS2 rgPins2; REGPINTYPES rgPinType; static WCHAR wszPinName[] = {'P', 'i', 'n', 0 }; static const WCHAR wszFilterName1[] = {'T', 'e', 's', 't', 'f', 'i', 'l', 't', 'e', 'r', '1', 0 }; static const WCHAR wszFilterName2[] = {'T', 'e', 's', 't', 'f', 'i', 'l', 't', 'e', 'r', '2', 0 }; CLSID clsidFilter1; CLSID clsidFilter2; hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&pMapper); ok(hr == S_OK, "CoCreateInstance failed with %x\n", hr); if (FAILED(hr)) goto out; hr = CoCreateGuid(&clsidFilter1); ok(hr == S_OK, "CoCreateGuid failed with %x\n", hr); hr = CoCreateGuid(&clsidFilter2); ok(hr == S_OK, "CoCreateGuid failed with %x\n", hr); rgPinType.clsMajorType = &GUID_NULL; /* Make sure quartz accepts it without crashing */ rgPinType.clsMinorType = NULL; /* Test with pin descript version 1 */ ZeroMemory(&rgf2, sizeof(rgf2)); rgf2.dwVersion = 1; rgf2.dwMerit = MERIT_UNLIKELY; S1(U(rgf2)).cPins = 1; S1(U(rgf2)).rgPins = &rgPins; rgPins.strName = wszPinName; rgPins.bRendered = 1; rgPins.bOutput = 0; rgPins.bZero = 0; rgPins.bMany = 0; rgPins.clsConnectsToFilter = NULL; rgPins.strConnectsToPin = NULL; rgPins.nMediaTypes = 1; rgPins.lpMediaType = &rgPinType; hr = IFilterMapper2_RegisterFilter(pMapper, &clsidFilter1, wszFilterName1, NULL, &CLSID_LegacyAmFilterCategory, NULL, &rgf2); if (hr == E_ACCESSDENIED) { skip("Not authorized to register filters\n"); goto out; } ok(hr == S_OK, "IFilterMapper2_RegisterFilter failed with %x\n", hr); hr = IFilterMapper2_UnregisterFilter(pMapper, &CLSID_LegacyAmFilterCategory, NULL, &clsidFilter1); ok(hr == S_OK, "FilterMapper_UnregisterFilter failed with %x\n", hr); /* Test with pin descript version 2 */ ZeroMemory(&rgf2, sizeof(rgf2)); rgf2.dwVersion = 2; rgf2.dwMerit = MERIT_UNLIKELY; S2(U(rgf2)).cPins2 = 1; S2(U(rgf2)).rgPins2 = &rgPins2; rgPins2.dwFlags = REG_PINFLAG_B_RENDERER; rgPins2.cInstances = 1; rgPins2.nMediaTypes = 1; rgPins2.lpMediaType = &rgPinType; rgPins2.nMediums = 0; rgPins2.lpMedium = NULL; rgPins2.clsPinCategory = NULL; hr = IFilterMapper2_RegisterFilter(pMapper, &clsidFilter2, wszFilterName2, NULL, &CLSID_LegacyAmFilterCategory, NULL, &rgf2); ok(hr == S_OK, "IFilterMapper2_RegisterFilter failed with %x\n", hr); hr = IFilterMapper2_UnregisterFilter(pMapper, &CLSID_LegacyAmFilterCategory, NULL, &clsidFilter2); ok(hr == S_OK, "FilterMapper_UnregisterFilter failed with %x\n", hr); out: if (pMapper) IFilterMapper2_Release(pMapper); }
int copyb(void) { int i, j, state; Tchar ii; int req, k; Offset savoff; Uchar *p; if (skip() || !(j = getrq())) j = '.'; req = j; p = unpair(j); /* was: k = j >> BYTE; j &= BYTEMASK; */ j = p[0]; k = p[1]; copyf++; flushi(); nlflg = 0; state = 1; /* state 0 eat up * state 1 look for . * state 2 look for first char of end macro * state 3 look for second char of end macro */ while (1) { i = cbits(ii = getch()); if (state == 3) { if (i == k) break; if (!k) { ch = ii; i = getach(); ch = ii; if (!i) break; } state = 0; goto c0; } if (i == '\n') { state = 1; nlflg = 0; goto c0; } if (state == 1 && i == '.') { state++; savoff = offset; goto c0; } if (state == 2 && i == j) { state++; goto c0; } state = 0; c0: if (offset) wbf(ii); } if (offset) { offset = savoff; wbf((Tchar)0); } copyf--; return(req); }
static void test_fm2_enummatchingfilters(void) { IFilterMapper2 *pMapper = NULL; HRESULT hr; REGFILTER2 rgf2; REGFILTERPINS2 rgPins2[2]; REGPINTYPES rgPinType; static const WCHAR wszFilterName1[] = {'T', 'e', 's', 't', 'f', 'i', 'l', 't', 'e', 'r', '1', 0 }; static const WCHAR wszFilterName2[] = {'T', 'e', 's', 't', 'f', 'i', 'l', 't', 'e', 'r', '2', 0 }; CLSID clsidFilter1; CLSID clsidFilter2; IEnumMoniker *pEnum = NULL; BOOL found, registered = TRUE; ZeroMemory(&rgf2, sizeof(rgf2)); hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&pMapper); ok(hr == S_OK, "CoCreateInstance failed with %x\n", hr); if (FAILED(hr)) goto out; hr = CoCreateGuid(&clsidFilter1); ok(hr == S_OK, "CoCreateGuid failed with %x\n", hr); hr = CoCreateGuid(&clsidFilter2); ok(hr == S_OK, "CoCreateGuid failed with %x\n", hr); /* Test that a test renderer filter is returned when enumerating filters with bRender=FALSE */ rgf2.dwVersion = 2; rgf2.dwMerit = MERIT_UNLIKELY; S2(U(rgf2)).cPins2 = 1; S2(U(rgf2)).rgPins2 = rgPins2; rgPins2[0].dwFlags = REG_PINFLAG_B_RENDERER; rgPins2[0].cInstances = 1; rgPins2[0].nMediaTypes = 1; rgPins2[0].lpMediaType = &rgPinType; rgPins2[0].nMediums = 0; rgPins2[0].lpMedium = NULL; rgPins2[0].clsPinCategory = NULL; rgPinType.clsMajorType = &GUID_NULL; rgPinType.clsMinorType = &GUID_NULL; hr = IFilterMapper2_RegisterFilter(pMapper, &clsidFilter1, wszFilterName1, NULL, &CLSID_LegacyAmFilterCategory, NULL, &rgf2); if (hr == E_ACCESSDENIED) { registered = FALSE; skip("Not authorized to register filters\n"); } else { ok(hr == S_OK, "IFilterMapper2_RegisterFilter failed with %x\n", hr); rgPins2[0].dwFlags = 0; rgPins2[1].dwFlags = REG_PINFLAG_B_OUTPUT; rgPins2[1].cInstances = 1; rgPins2[1].nMediaTypes = 1; rgPins2[1].lpMediaType = &rgPinType; rgPins2[1].nMediums = 0; rgPins2[1].lpMedium = NULL; rgPins2[1].clsPinCategory = NULL; S2(U(rgf2)).cPins2 = 2; hr = IFilterMapper2_RegisterFilter(pMapper, &clsidFilter2, wszFilterName2, NULL, &CLSID_LegacyAmFilterCategory, NULL, &rgf2); ok(hr == S_OK, "IFilterMapper2_RegisterFilter failed with %x\n", hr); hr = IFilterMapper2_EnumMatchingFilters(pMapper, &pEnum, 0, TRUE, MERIT_UNLIKELY, TRUE, 0, NULL, NULL, &GUID_NULL, FALSE, FALSE, 0, NULL, NULL, &GUID_NULL); ok(hr == S_OK, "IFilterMapper2_EnumMatchingFilters failed with %x\n", hr); if (SUCCEEDED(hr) && pEnum) { found = enum_find_filter(wszFilterName1, pEnum); ok(found, "EnumMatchingFilters failed to return the test filter 1\n"); } if (pEnum) IEnumMoniker_Release(pEnum); pEnum = NULL; hr = IFilterMapper2_EnumMatchingFilters(pMapper, &pEnum, 0, TRUE, MERIT_UNLIKELY, TRUE, 0, NULL, NULL, &GUID_NULL, FALSE, FALSE, 0, NULL, NULL, &GUID_NULL); ok(hr == S_OK, "IFilterMapper2_EnumMatchingFilters failed with %x\n", hr); if (SUCCEEDED(hr) && pEnum) { found = enum_find_filter(wszFilterName2, pEnum); ok(found, "EnumMatchingFilters failed to return the test filter 2\n"); } if (pEnum) IEnumMoniker_Release(pEnum); pEnum = NULL; /* Non renderer must not be returned with bRender=TRUE */ hr = IFilterMapper2_EnumMatchingFilters(pMapper, &pEnum, 0, TRUE, MERIT_UNLIKELY, TRUE, 0, NULL, NULL, &GUID_NULL, TRUE, FALSE, 0, NULL, NULL, &GUID_NULL); ok(hr == S_OK, "IFilterMapper2_EnumMatchingFilters failed with %x\n", hr); if (SUCCEEDED(hr) && pEnum) { found = enum_find_filter(wszFilterName1, pEnum); ok(found, "EnumMatchingFilters failed to return the test filter 1\n"); } } if (pEnum) IEnumMoniker_Release(pEnum); pEnum = NULL; hr = IFilterMapper2_EnumMatchingFilters(pMapper, &pEnum, 0, TRUE, MERIT_UNLIKELY, TRUE, 0, NULL, NULL, &GUID_NULL, TRUE, FALSE, 0, NULL, NULL, &GUID_NULL); ok(hr == S_OK, "IFilterMapper2_EnumMatchingFilters failed with %x\n", hr); if (SUCCEEDED(hr) && pEnum) { found = enum_find_filter(wszFilterName2, pEnum); ok(!found, "EnumMatchingFilters should not return the test filter 2\n"); } if (registered) { hr = IFilterMapper2_UnregisterFilter(pMapper, &CLSID_LegacyAmFilterCategory, NULL, &clsidFilter1); ok(SUCCEEDED(hr), "IFilterMapper2_UnregisterFilter failed with %x\n", hr); hr = IFilterMapper2_UnregisterFilter(pMapper, &CLSID_LegacyAmFilterCategory, NULL, &clsidFilter2); ok(SUCCEEDED(hr), "IFilterMapper2_UnregisterFilter failed with %x\n", hr); } out: if (pEnum) IEnumMoniker_Release(pEnum); if (pMapper) IFilterMapper2_Release(pMapper); }
void casetl(void) { int j; int w[3]; Tchar buf[LNSIZE]; Tchar *tp; Tchar i, delim; /* * bug fix * * if .tl is the first thing in the file, the p1 * doesn't come out, also the pagenumber will be 0 * * tends too confuse the device filter (and the user as well) */ if (dip == d && numtabp[NL].val == -1) newline(1); dip->nls = 0; skip(); if (ismot(delim = getch())) { ch = delim; delim = '\''; } else delim = cbits(delim); tp = buf; numtabp[HP].val = 0; w[0] = w[1] = w[2] = 0; j = 0; while (cbits(i = getch()) != '\n') { if (cbits(i) == cbits(delim)) { if (j < 3) w[j] = numtabp[HP].val; numtabp[HP].val = 0; if (w[j] != 0) *tp++ = WORDSP; j++; *tp++ = 0; } else { if (cbits(i) == pagech) { setn1(numtabp[PN].val, numtabp[findr('%')].fmt, i&SFMASK); continue; } numtabp[HP].val += width(i); if (tp < &buf[LNSIZE-10]) { if (cbits(i) == ' ' && *tp != WORDSP) *tp++ = WORDSP; *tp++ = i; } else { ERROR "Overflow in casetl" WARN; } } } if (j<3) w[j] = numtabp[HP].val; *tp++ = 0; *tp++ = 0; *tp = 0; tp = buf; if (NROFF) horiz(po); while (i = *tp++) pchar(i); if (w[1] || w[2]) horiz(j = quant((lt - w[1]) / 2 - w[0], HOR)); while (i = *tp++) pchar(i); if (w[2]) { horiz(lt - w[0] - w[1] - w[2] - j); while (i = *tp++) pchar(i); } newline(0); if (dip != d) { if (dip->dnl > dip->hnl) dip->hnl = dip->dnl; } else { if (numtabp[NL].val > dip->hnl) dip->hnl = numtabp[NL].val; } }
void Parse(MTextAddOn& ao) { const char *inclStart, *inclEnd; const char *txt; char path[PATH_MAX]; txt = skip(ao.Text(), '<'); while (*txt) { if (txt[0] == '!' && txt[1] == '-' && txt[2] == '-') { // we have a comment do { txt = skip_white(txt + 3); if (*txt++ != '#') break; if (strncmp(txt, "include", 7)) break; txt = skip_white(txt + 7); if (*txt++ != '"') break; int l = 0; while (l < PATH_MAX && *txt && *txt != '"') path[l++] = *txt++; if (*txt != '"') break; path[l] = 0; do txt = skip_nc(txt + 1, '-'); while (*txt && *txt != '-'); if (*txt == 0) break; txt = skip_nc(txt + 1, '>'); inclStart = txt; do { do txt = skip(txt, '<'); while (*txt && ! (txt[0] == '!' && txt[1] == '-' && txt[2] == '-')); if (*txt == 0) break; inclEnd = txt - 1; txt = skip_white(txt + 3); if (strncmp(txt, "end", 3) == 0) { txt = skip_white(txt + 3); if (strncmp(txt, "include", 7) == 0) break; } } while (*txt); if (*txt == 0) break; txt = DoInclude(ao, path, inclStart, inclEnd); } while (false); } txt = skip_nc(txt, '>'); txt = skip(txt, '<'); } } /* Parse */
void AVIReader::grabReadFrame(int Frame, unsigned char* imgdata) { skip(Frame); grabFrame(); readCurFrameRGB(imgdata); }
u32 nextU32() { u32 v = 0; for (skip(); b > 32; read()) v = v*10 + b-48; return v; }
// ------------------------------------------------ // Function: dhcp_send() // ------------------------------------------------ // Input: Message type // TRUE to broadcast answer // Output: TRUE if succesful // ------------------------------------------------ // Description: Send a DHCP message // ------------------------------------------------ BOOL dhcp_send(BYTE type, BOOL broadcast) { PPBUF buf; buf = udp_new(SOCKET_DHCP); if(buf == NULL) return FALSE; DHCP(buf->data)->op = 1; // BOOTREQUEST DHCP(buf->data)->htype = 1; // ETH 10MBPS DHCP(buf->data)->hlen = 6; // 6 bytes ETH MAC DHCP(buf->data)->hops = 0; DHCP(buf->data)->xid = xid.d; DHCP(buf->data)->secs = 0; if(broadcast) { DHCP(buf->data)->flags = HTONS(0x8000); // server must broadcast answer DHCP(buf->data)->ci.d = 0; } else { DHCP(buf->data)->flags = 0; // server must send unicast answer DHCP(buf->data)->ci.d = ip_local[INTERFACE_ETH].d; } DHCP(buf->data)->yi.d = 0; DHCP(buf->data)->gi.d = 0; DHCP(buf->data)->si.d = ip_dhcp.d; os_set((BYTE *)(&DHCP(buf->data)->chaddr), 0, 16+64+128); os_copy((BYTE *)&mac_local, (BYTE *)(&DHCP(buf->data)->chaddr), sizeof(MACADDR)); // -------------- // insert options // -------------- skip(buf, BOOTP_HDR_SIZE); buf->size = BOOTP_HDR_SIZE; write_uint32(buf, 0x63825363); // magic cookie write_byte(buf, DHCP_OPT_TYPE); // DHCP message type write_byte(buf, 1); write_byte(buf, type); write_byte(buf, DHCP_OPT_ID); // DHCP source ID write_byte(buf, 7); write_byte(buf, 1); write_buf(buf, (BYTE *)&mac_local, sizeof(MACADDR)); write_byte(buf, DHCP_OPT_IP); // Request IP address write_byte(buf, 4); write_ip(buf, ip_tmp); #ifdef _DNS write_byte(buf, DHCP_OPT_REQ); // Request options write_byte(buf, 3); write_byte(buf, DHCP_OPT_MASK); write_byte(buf, DHCP_OPT_ROUTER); write_byte(buf, DHCP_OPT_DNS); #else write_byte(buf, DHCP_OPT_REQ); // Request options write_byte(buf, 2); write_byte(buf, DHCP_OPT_MASK); write_byte(buf, DHCP_OPT_ROUTER); #endif write_byte(buf, DHCP_OPT_END); // done with options udp_send(buf); release_buffer(buf); return TRUE; }
static void test_PSetupEnumMonitor(VOID) { HANDLE mi; WCHAR buffer[MAX_PATH+2]; DWORD minsize = 0; DWORD size; DWORD res; DWORD index=0; SetLastError(0xdeadbeef); mi = pPSetupCreateMonitorInfo(NULL, NULL, NULL); if (!mi) { skip("PSetupCreateMonitorInfo\n"); return; } minsize = 0; SetLastError(0xdeadbeef); res = pPSetupEnumMonitor(mi, 0, NULL, &minsize); ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER) && (minsize > 0), "got %u with %u and %u (expected '0' with ERROR_INSUFFICIENT_BUFFER " "and '> 0')\n", res, GetLastError(), minsize); size = sizeof(buffer) / sizeof(buffer[0]); if ((minsize + 1) > size) { skip("overflow: %u\n", minsize); pPSetupDestroyMonitorInfo(mi); return; } if (0) { /* XP: ERROR_INVALID_PARAMETER, w2k: Crash */ SetLastError(0xdeadbeef); size = sizeof(buffer) / sizeof(buffer[0]); res = pPSetupEnumMonitor(NULL, 0, buffer, &size); ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER), "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n", res, GetLastError()); } if (0) { /* XP: Crash, w2k: Success (how can that work?) */ SetLastError(0xdeadbeef); size = sizeof(buffer) / sizeof(buffer[0]); res = pPSetupEnumMonitor(mi, 0, NULL, &size); trace("got %u with %u and %u\n", res, GetLastError(), size); } if (0) { /* XP: ERROR_INVALID_PARAMETER, w2k: Crash */ SetLastError(0xdeadbeef); res = pPSetupEnumMonitor(mi, 0, buffer, NULL); ok( !res && (GetLastError() == ERROR_INVALID_PARAMETER), "got %u with %u (expected '0' with ERROR_INVALID_PARAMETER)\n", res, GetLastError()); } SetLastError(0xdeadbeef); size = minsize - 1; res = pPSetupEnumMonitor(mi, 0, buffer, &size); ok( !res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER), "got %u with %u and %u (expected '0' with ERROR_INSUFFICIENT_BUFFER)\n", res, GetLastError(), size); SetLastError(0xdeadbeef); size = minsize; res = pPSetupEnumMonitor(mi, 0, buffer, &size); ok( res, "got %u with %u and %u (expected '!= 0')\n", res, GetLastError(), size); SetLastError(0xdeadbeef); size = minsize + 1; res = pPSetupEnumMonitor(mi, 0, buffer, &size); ok( res, "got %u with %u and %u (expected '!= 0')\n", res, GetLastError(), size); /* try max. 20 monitors */ while (res && (index < 20)) { SetLastError(0xdeadbeef); buffer[0] = '\0'; size = sizeof(buffer) / sizeof(buffer[0]); res = pPSetupEnumMonitor(mi, index, buffer, &size); ok( res || (GetLastError() == ERROR_NO_MORE_ITEMS), "(%u) got %u with %u and %u (expected '!=0' or: '0' with " "ERROR_NO_MORE_ITEMS)\n", index, res, GetLastError(), size); if (res) index++; } pPSetupDestroyMonitorInfo(mi); }