ReactOS 0.4.16-dev-320-g3bd9ddc
Classes | Macros | Enumerations | Functions | Variables
notification.c File Reference
#include <stdarg.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <winhttp.h>
#include "wine/test.h"
Include dependency graph for notification.c:

Go to the source code of this file.

Classes

struct  notification
 
struct  info
 
struct  test_request
 
struct  server_info
 

Macros

#define NF_ALLOW   0x0001 /* notification may or may not happen */
 
#define NF_WINE_ALLOW   0x0002 /* wine sends notification when it should not */
 
#define NF_SIGNAL   0x0004 /* signal wait handle when notified */
 
#define server_read_data(a)   _server_read_data(a,__LINE__)
 
#define read_request_data(a, b, c, d)   _read_request_data(a,b,c,d,__LINE__)
 

Enumerations

enum  api {
  winhttp_connect = 1 , winhttp_open_request , winhttp_send_request , winhttp_receive_response ,
  winhttp_query_data , winhttp_read_data , winhttp_write_data , winhttp_close_handle ,
  internet_connect = 1 , http_open_request , http_send_request_ex , internet_writefile ,
  http_end_request , internet_close_handle
}
 

Functions

static void CALLBACK check_notification (HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD buflen)
 
static void setup_test (struct info *info, enum api function, unsigned int line)
 
static void end_test (struct info *info, unsigned int line)
 
static void test_connection_cache (void)
 
static void test_redirect (void)
 
static void test_async (void)
 
static DWORD CALLBACK server_thread (LPVOID param)
 
static void test_basic_request (int port, const WCHAR *verb, const WCHAR *path)
 
static void open_async_request (int port, struct test_request *req, struct info *info, const WCHAR *path, BOOL reuse_connection)
 
static void open_socket_request (int port, struct test_request *req, struct info *info)
 
static void server_send_reply (struct test_request *req, struct info *info, const char *msg)
 
static void _server_read_data (const char *expect_prefix, unsigned int line)
 
static void close_request (struct test_request *req, struct info *info, BOOL allow_closing_connection)
 
static void _read_request_data (struct test_request *req, struct info *info, const char *expected_data, BOOL closing_connection, unsigned line)
 
static void test_persistent_connection (int port)
 
 START_TEST (notification)
 

Variables

static const WCHAR user_agent [] = {'w','i','n','e','t','e','s','t',0}
 
static const WCHAR test_winehq [] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0}
 
static const WCHAR tests_hello_html [] = {'/','t','e','s','t','s','/','h','e','l','l','o','.','h','t','m','l',0}
 
static const WCHAR tests_redirect [] = {'/','t','e','s','t','s','/','r','e','d','i','r','e','c','t',0}
 
static const WCHAR localhostW [] = {'l','o','c','a','l','h','o','s','t',0}
 
static const struct notification cache_test []
 
static const struct notification redirect_test []
 
static const struct notification async_test []
 
static const char okmsg []
 
static const char page1 []
 
static int server_socket
 
static HANDLE server_socket_available
 
static HANDLE server_socket_done
 
static const struct notification open_socket_request_test []
 
static const struct notification reuse_socket_request_test []
 
static const struct notification server_reply_test []
 
static const struct notification close_request_test []
 
static const struct notification close_allow_connection_close_request_test []
 
static const struct notification read_test []
 
static const struct notification read_allow_close_test []
 

Macro Definition Documentation

◆ NF_ALLOW

#define NF_ALLOW   0x0001 /* notification may or may not happen */

Definition at line 56 of file notification.c.

◆ NF_SIGNAL

#define NF_SIGNAL   0x0004 /* signal wait handle when notified */

Definition at line 58 of file notification.c.

◆ NF_WINE_ALLOW

#define NF_WINE_ALLOW   0x0002 /* wine sends notification when it should not */

Definition at line 57 of file notification.c.

◆ read_request_data

#define read_request_data (   a,
  b,
  c,
  d 
)    _read_request_data(a,b,c,d,__LINE__)

Definition at line 919 of file notification.c.

◆ server_read_data

#define server_read_data (   a)    _server_read_data(a,__LINE__)

Definition at line 843 of file notification.c.

Enumeration Type Documentation

◆ api

enum api
Enumerator
winhttp_connect 
winhttp_open_request 
winhttp_send_request 
winhttp_receive_response 
winhttp_query_data 
winhttp_read_data 
winhttp_write_data 
winhttp_close_handle 
internet_connect 
http_open_request 
http_send_request_ex 
internet_writefile 
http_end_request 
internet_close_handle 

Definition at line 37 of file notification.c.

38{
39 winhttp_connect = 1,
40 winhttp_open_request,
41 winhttp_send_request,
42 winhttp_receive_response,
43 winhttp_query_data,
44 winhttp_read_data,
45 winhttp_write_data,
46 winhttp_close_handle
47};
winhttp_connect
@ winhttp_connect
Definition: notification.c:39
winhttp_read_data
@ winhttp_read_data
Definition: notification.c:44
winhttp_write_data
@ winhttp_write_data
Definition: notification.c:45
winhttp_query_data
@ winhttp_query_data
Definition: notification.c:43
winhttp_open_request
@ winhttp_open_request
Definition: notification.c:40
winhttp_send_request
@ winhttp_send_request
Definition: notification.c:41
winhttp_receive_response
@ winhttp_receive_response
Definition: notification.c:42
winhttp_close_handle
@ winhttp_close_handle
Definition: notification.c:46

Function Documentation

◆ _read_request_data()

static void _read_request_data ( struct test_request *  req,
struct info *  info,
const char *  expected_data,
BOOL  closing_connection,
unsigned  line 
)
static

Definition at line 920 of file notification.c.

921{
922 char buffer[1024];
923 DWORD len;
924 BOOL ret;
925
926 if (closing_connection)
927 {
928 info->test = read_allow_close_test;
929 info->count = ARRAY_SIZE( read_allow_close_test );
930 }
931 else
932 {
933 info->test = read_test;
934 info->count = ARRAY_SIZE( read_test );
935 }
936 info->index = 0;
937
938 setup_test( info, winhttp_read_data, line );
939 memset(buffer, '?', sizeof(buffer));
940 ret = WinHttpReadData( req->request, buffer, sizeof(buffer), NULL );
941 ok(ret, "failed to read data %u\n", GetLastError());
942
943 WaitForSingleObject( info->wait, INFINITE );
944
945 len = strlen(expected_data);
946 ok(!memcmp(buffer, expected_data, len), "unexpected data\n");
947}
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
ok
#define ok(value,...)
Definition: atltest.h:57
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
NULL
#define NULL
Definition: types.h:112
INFINITE
#define INFINITE
Definition: serial.h:102
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
buffer
GLuint buffer
Definition: glext.h:5915
len
GLenum GLsizei len
Definition: glext.h:6722
setup_test
static void setup_test(struct info *info, enum api function, unsigned int line)
Definition: notification.c:163
read_test
static const struct notification read_test[]
Definition: notification.c:903
read_allow_close_test
static const struct notification read_allow_close_test[]
Definition: notification.c:910
WinHttpReadData
BOOL WINAPI WinHttpReadData(HINTERNET hrequest, LPVOID buffer, DWORD to_read, LPDWORD read)
Definition: request.c:3053
memset
#define memset(x, y, z)
Definition: compat.h:39
info::index
unsigned int index
Definition: notification.c:65
info::test
const struct notification * test
Definition: notification.c:63
info::wait
HANDLE wait
Definition: notification.c:66
info::count
unsigned int count
Definition: notification.c:64
line
Definition: parser.c:49
test_request::request
HINTERNET request
Definition: notification.c:74
WaitForSingleObject
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
ret
int ret
Definition: wcstombs-tests.c:31
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042

◆ _server_read_data()

static void _server_read_data ( const char *  expect_prefix,
unsigned int  line 
)
static

Definition at line 844 of file notification.c.

845{
846 char buf[1024];
847 DWORD size, len;
848
849 size = recv( server_socket, buf, sizeof(buf), 0 );
850 len = strlen( expect_prefix );
851 ok_(__FILE__,line)(size > len, "data too short\n");
852 if (size >= len)
853 {
854 buf[len] = 0;
855 ok_(__FILE__,line)(!strcmp( buf, expect_prefix ), "unexpected data \"%s\"\n", buf);
856 }
857}
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
recv
INT WSAAPI recv(IN SOCKET s, OUT CHAR FAR *buf, IN INT len, IN INT flags)
Definition: recv.c:23
size
GLsizeiptr size
Definition: glext.h:5919
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
server_socket
static int server_socket
Definition: notification.c:641

◆ check_notification()

static void CALLBACK check_notification ( HINTERNET  handle,
DWORD_PTR  context,
DWORD  status,
LPVOID  buffer,
DWORD  buflen 
)
static

Definition at line 77 of file notification.c.

78{
79 BOOL status_ok, function_ok;
80 struct info *info = (struct info *)context;
81
82 if (status == WINHTTP_CALLBACK_STATUS_HANDLE_CREATED)
83 {
84 DWORD size = sizeof(struct info *);
85 WinHttpQueryOption( handle, WINHTTP_OPTION_CONTEXT_VALUE, &info, &size );
86 }
87 while (info->index < info->count && info->test[info->index].status != status && (info->test[info->index].flags & NF_ALLOW))
88 info->index++;
89 while (info->index < info->count && (info->test[info->index].flags & NF_WINE_ALLOW))
90 {
91 todo_wine ok(info->test[info->index].status != status, "unexpected %x notification\n", status);
92 if (info->test[info->index].status == status) break;
93 info->index++;
94 }
95 ok(info->index < info->count, "%u: unexpected notification 0x%08x\n", info->line, status);
96 if (info->index >= info->count) return;
97
98 status_ok = (info->test[info->index].status == status);
99 function_ok = (info->test[info->index].function == info->function);
100 ok(status_ok, "%u: expected status 0x%08x got 0x%08x\n", info->line, info->test[info->index].status, status);
101 ok(function_ok, "%u: expected function %u got %u\n", info->line, info->test[info->index].function, info->function);
102
103 if (status_ok && function_ok && info->test[info->index++].flags & NF_SIGNAL)
104 {
105 SetEvent( info->wait );
106 }
107}
WinHttpQueryOption
BOOL WINAPI WinHttpQueryOption(HINTERNET handle, DWORD option, LPVOID buffer, LPDWORD buflen)
Definition: session.c:1253
todo_wine
#define todo_wine
Definition: custom.c:89
NF_ALLOW
#define NF_ALLOW
Definition: notification.c:56
NF_WINE_ALLOW
#define NF_WINE_ALLOW
Definition: notification.c:57
NF_SIGNAL
#define NF_SIGNAL
Definition: notification.c:58
context
Definition: http.c:7252
info::line
unsigned int line
Definition: notification.c:67
info::function
enum api function
Definition: notification.c:62
status
Definition: ps.c:97
SetEvent
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
WINHTTP_OPTION_CONTEXT_VALUE
#define WINHTTP_OPTION_CONTEXT_VALUE
Definition: winhttp.h:112
WINHTTP_CALLBACK_STATUS_HANDLE_CREATED
#define WINHTTP_CALLBACK_STATUS_HANDLE_CREATED
Definition: winhttp.h:390

Referenced by open_async_request(), test_async(), test_connection_cache(), and test_redirect().

◆ close_request()

static void close_request ( struct test_request *  req,
struct info *  info,
BOOL  allow_closing_connection 
)
static

Definition at line 875 of file notification.c.

876{
877 BOOL ret;
878
879 if (allow_closing_connection)
880 {
881 info->test = close_allow_connection_close_request_test;
882 info->count = ARRAY_SIZE( close_allow_connection_close_request_test );
883 }
884 else
885 {
886 info->test = close_request_test;
887 info->count = ARRAY_SIZE( close_request_test );
888 }
889 info->index = 0;
890 setup_test( info, winhttp_close_handle, __LINE__ );
891
892 ret = WinHttpCloseHandle( req->request );
893 ok(ret, "WinHttpCloseHandle failed: %u\n", GetLastError());
894 ret = WinHttpCloseHandle( req->connection );
895 ok(ret, "WinHttpCloseHandle failed: %u\n", GetLastError());
896 ret = WinHttpCloseHandle( req->session );
897 ok(ret, "WinHttpCloseHandle failed: %u\n", GetLastError());
898
899 WaitForSingleObject( info->wait, INFINITE );
900 end_test( info, __LINE__ );
901}
end_test
@ end_test
Definition: FsRtlMcb.c:1246
WinHttpCloseHandle
BOOL WINAPI WinHttpCloseHandle(HINTERNET handle)
Definition: session.c:1195
close_request_test
static const struct notification close_request_test[]
Definition: notification.c:859
close_allow_connection_close_request_test
static const struct notification close_allow_connection_close_request_test[]
Definition: notification.c:866
test_request::session
HINTERNET session
Definition: notification.c:72
test_request::connection
HINTERNET connection
Definition: notification.c:73

◆ end_test()

static void end_test ( struct info *  info,
unsigned int  line 
)
static

Definition at line 176 of file notification.c.

177{
178 ok_(__FILE__,line)(info->index == info->count, "some notifications were missing: %x\n",
179 info->test[info->index].status);
180}

◆ open_async_request()

static void open_async_request ( int  port,
struct test_request *  req,
struct info *  info,
const WCHAR *  path,
BOOL  reuse_connection 
)
static

Definition at line 774 of file notification.c.

775{
776 BOOL ret;
777
778 info->index = 0;
779 if (reuse_connection)
780 {
781 info->test = reuse_socket_request_test;
782 info->count = ARRAY_SIZE( reuse_socket_request_test );
783 }
784 else
785 {
786 info->test = open_socket_request_test;
787 info->count = ARRAY_SIZE( open_socket_request_test );
788 }
789
790 req->session = WinHttpOpen( user_agent, 0, NULL, NULL, WINHTTP_FLAG_ASYNC );
791 ok(req->session != NULL, "failed to open session %u\n", GetLastError());
792
793 WinHttpSetOption( req->session, WINHTTP_OPTION_CONTEXT_VALUE, &info, sizeof(struct info *) );
794 WinHttpSetStatusCallback( req->session, check_notification, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS, 0 );
795
796 setup_test( info, winhttp_connect, __LINE__ );
797 req->connection = WinHttpConnect( req->session, localhostW, port, 0 );
798 ok(req->connection != NULL, "failed to open a connection %u\n", GetLastError());
799
800 setup_test( info, winhttp_open_request, __LINE__ );
801 req->request = WinHttpOpenRequest( req->connection, NULL, path, NULL, NULL, NULL, 0 );
802 ok(req->request != NULL, "failed to open a request %u\n", GetLastError());
803
804 setup_test( info, winhttp_send_request, __LINE__ );
805 ret = WinHttpSendRequest( req->request, NULL, 0, NULL, 0, 0, 0 );
806 ok(ret, "failed to send request %u\n", GetLastError());
807}
port
USHORT port
Definition: uri.c:228
WinHttpOpen
HINTERNET WINAPI WinHttpOpen(LPCWSTR agent, DWORD access, LPCWSTR proxy, LPCWSTR bypass, DWORD flags)
Definition: session.c:250
WinHttpConnect
HINTERNET WINAPI WinHttpConnect(HINTERNET hsession, LPCWSTR server, INTERNET_PORT port, DWORD reserved)
Definition: session.c:541
WinHttpOpenRequest
HINTERNET WINAPI WinHttpOpenRequest(HINTERNET hconnect, LPCWSTR verb, LPCWSTR object, LPCWSTR version, LPCWSTR referrer, LPCWSTR *types, DWORD flags)
Definition: session.c:1117
WinHttpSetOption
BOOL WINAPI WinHttpSetOption(HINTERNET handle, DWORD option, LPVOID buffer, DWORD buflen)
Definition: session.c:1312
WinHttpSetStatusCallback
WINHTTP_STATUS_CALLBACK WINAPI WinHttpSetStatusCallback(HINTERNET handle, WINHTTP_STATUS_CALLBACK callback, DWORD flags, DWORD_PTR reserved)
Definition: session.c:2056
reuse_socket_request_test
static const struct notification reuse_socket_request_test[]
Definition: notification.c:765
check_notification
static void CALLBACK check_notification(HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD buflen)
Definition: notification.c:77
localhostW
static const WCHAR localhostW[]
Definition: notification.c:35
user_agent
static const WCHAR user_agent[]
Definition: notification.c:31
open_socket_request_test
static const struct notification open_socket_request_test[]
Definition: notification.c:751
WinHttpSendRequest
BOOL WINAPI WinHttpSendRequest(HINTERNET hrequest, LPCWSTR headers, DWORD headers_len, LPVOID optional, DWORD optional_len, DWORD total_len, DWORD_PTR context)
Definition: request.c:2350
WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS
#define WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS
Definition: winhttp.h:421
WINHTTP_FLAG_ASYNC
#define WINHTTP_FLAG_ASYNC
Definition: winhttp.h:51

Referenced by open_socket_request(), and test_persistent_connection().

◆ open_socket_request()

static void open_socket_request ( int  port,
struct test_request *  req,
struct info *  info 
)
static

Definition at line 809 of file notification.c.

810{
811 static const WCHAR socketW[] = {'/','s','o','c','k','e','t',0};
812
813 ResetEvent( server_socket_done );
814 open_async_request( port, req, info, socketW, FALSE );
815 WaitForSingleObject( server_socket_available, INFINITE );
816}
FALSE
#define FALSE
Definition: types.h:117
open_async_request
static void open_async_request(int port, struct test_request *req, struct info *info, const WCHAR *path, BOOL reuse_connection)
Definition: notification.c:774
server_socket_available
static HANDLE server_socket_available
Definition: notification.c:642
server_socket_done
static HANDLE server_socket_done
Definition: notification.c:642
ResetEvent
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:714
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by test_persistent_connection().

◆ server_send_reply()

static void server_send_reply ( struct test_request *  req,
struct info *  info,
const char *  msg 
)
static

Definition at line 825 of file notification.c.

826{
827 BOOL ret;
828
829 send( server_socket, msg, strlen( msg ), 0 );
830 WaitForSingleObject( info->wait, INFINITE );
831
832 info->test = server_reply_test;
833 info->count = ARRAY_SIZE( server_reply_test );
834 info->index = 0;
835 setup_test( info, winhttp_send_request, __LINE__ );
836 ret = WinHttpReceiveResponse( req->request, NULL );
837 ok(ret, "failed to receive response %u\n", GetLastError());
838
839 WaitForSingleObject( info->wait, INFINITE );
840 end_test( info, __LINE__ );
841}
msg
#define msg(x)
Definition: auth_time.c:54
send
INT WSAAPI send(IN SOCKET s, IN CONST CHAR FAR *buf, IN INT len, IN INT flags)
Definition: send.c:23
server_reply_test
static const struct notification server_reply_test[]
Definition: notification.c:818
WinHttpReceiveResponse
BOOL WINAPI WinHttpReceiveResponse(HINTERNET hrequest, LPVOID reserved)
Definition: request.c:2924

Referenced by test_persistent_connection().

◆ server_thread()

static DWORD CALLBACK server_thread ( LPVOID  param)
static

Definition at line 644 of file notification.c.

645{
646 struct server_info *si = param;
647 int r, c = -1, i, on;
648 SOCKET s;
649 struct sockaddr_in sa;
650 char buffer[0x100];
651 WSADATA wsaData;
652 int last_request = 0;
653
654 WSAStartup(MAKEWORD(1,1), &wsaData);
655
656 s = socket(AF_INET, SOCK_STREAM, 0);
657 if (s == INVALID_SOCKET)
658 return 1;
659
660 on = 1;
661 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on);
662
663 memset(&sa, 0, sizeof sa);
664 sa.sin_family = AF_INET;
665 sa.sin_port = htons(si->port);
666 sa.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
667
668 r = bind(s, (struct sockaddr *)&sa, sizeof(sa));
669 if (r < 0)
670 return 1;
671
672 listen(s, 0);
673 SetEvent(si->event);
674 do
675 {
676 if (c == -1) c = accept(s, NULL, NULL);
677
678 memset(buffer, 0, sizeof buffer);
679 for(i = 0; i < sizeof buffer - 1; i++)
680 {
681 r = recv(c, &buffer[i], 1, 0);
682 if (r != 1)
683 break;
684 if (i < 4) continue;
685 if (buffer[i - 2] == '\n' && buffer[i] == '\n' &&
686 buffer[i - 3] == '\r' && buffer[i - 1] == '\r')
687 break;
688 }
689 if (strstr(buffer, "GET /quit"))
690 {
691 send(c, okmsg, sizeof okmsg - 1, 0);
692 send(c, page1, sizeof page1 - 1, 0);
693 last_request = 1;
694 }
695 else if(strstr(buffer, "GET /socket"))
696 {
697 server_socket = c;
698 SetEvent(server_socket_available);
699 WaitForSingleObject(server_socket_done, INFINITE);
700 ResetEvent(server_socket_available);
701 }
702 shutdown(c, 2);
703 closesocket(c);
704 c = -1;
705 } while (!last_request);
706
707 closesocket(s);
708 return 0;
709}
strstr
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
inet_addr
ULONG WSAAPI inet_addr(IN CONST CHAR FAR *cp)
Definition: addrconv.c:71
sa
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
WSAStartup
INT WINAPI WSAStartup(IN WORD wVersionRequested, OUT LPWSADATA lpWSAData)
Definition: startup.c:113
SOCK_STREAM
#define SOCK_STREAM
Definition: tcpip.h:118
AF_INET
#define AF_INET
Definition: tcpip.h:117
s
GLdouble s
Definition: gl.h:2039
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
c
const GLubyte * c
Definition: glext.h:8905
param
GLfloat param
Definition: glext.h:5796
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
c
#define c
Definition: ke_i.h:80
htons
#define htons(x)
Definition: module.h:215
closesocket
#define closesocket
Definition: ncftp.h:477
okmsg
static const char okmsg[]
Definition: notification.c:624
page1
static const char page1[]
Definition: notification.c:629
setsockopt
INT WSAAPI setsockopt(IN SOCKET s, IN INT level, IN INT optname, IN CONST CHAR FAR *optval, IN INT optlen)
Definition: sockctrl.c:421
listen
INT WSAAPI listen(IN SOCKET s, IN INT backlog)
Definition: sockctrl.c:123
shutdown
INT WSAAPI shutdown(IN SOCKET s, IN INT how)
Definition: sockctrl.c:506
bind
INT WSAAPI bind(IN SOCKET s, IN CONST struct sockaddr *name, IN INT namelen)
Definition: socklife.c:36
accept
SOCKET WSAAPI accept(IN SOCKET s, OUT LPSOCKADDR addr, OUT INT FAR *addrlen)
Definition: socklife.c:23
socket
SOCKET WSAAPI socket(IN INT af, IN INT type, IN INT protocol)
Definition: socklife.c:143
server_info
Definition: nfs41_server.c:70
server_info::event
HANDLE event
Definition: notification.c:637
server_info::port
int port
Definition: notification.c:638
sockaddr_in
Definition: winsock.h:509
MAKEWORD
#define MAKEWORD(a, b)
Definition: typedefs.h:248
INVALID_SOCKET
#define INVALID_SOCKET
Definition: winsock.h:332
SOCKET
UINT_PTR SOCKET
Definition: winsock.h:47
SO_REUSEADDR
#define SO_REUSEADDR
Definition: winsock.h:180
SOL_SOCKET
#define SOL_SOCKET
Definition: winsock.h:398

Referenced by START_TEST().

◆ setup_test()

static void setup_test ( struct info *  info,
enum api  function,
unsigned int  line 
)
static

Definition at line 163 of file notification.c.

164{
165 if (info->wait) ResetEvent( info->wait );
166 info->function = function;
167 info->line = line;
168 while (info->index < info->count && info->test[info->index].function != function
169 && (info->test[info->index].flags & (NF_ALLOW | NF_WINE_ALLOW)))
170 info->index++;
171 ok_(__FILE__,line)(info->test[info->index].function == function,
172 "unexpected function %u, expected %u. probably some notifications were missing\n",
173 info->test[info->index].function, function);
174}

Referenced by _read_request_data(), close_request(), open_async_request(), server_send_reply(), test_async(), test_connection_cache(), and test_redirect().

◆ START_TEST()

START_TEST ( notification  )

Definition at line 1012 of file notification.c.

1013{
1014 static const WCHAR quitW[] = {'/','q','u','i','t',0};
1015 struct server_info si;
1016 HANDLE thread;
1017 DWORD ret;
1018
1019 test_connection_cache();
1020 test_redirect();
1021 test_async();
1022
1023 si.event = CreateEventW( NULL, 0, 0, NULL );
1024 si.port = 7533;
1025
1026 thread = CreateThread( NULL, 0, server_thread, &si, 0, NULL );
1027 ok(thread != NULL, "failed to create thread %u\n", GetLastError());
1028
1029 server_socket_available = CreateEventW( NULL, 0, 0, NULL );
1030 server_socket_done = CreateEventW( NULL, 0, 0, NULL );
1031
1032 ret = WaitForSingleObject( si.event, 10000 );
1033 ok(ret == WAIT_OBJECT_0, "failed to start winhttp test server %u\n", GetLastError());
1034 if (ret != WAIT_OBJECT_0)
1035 {
1036 CloseHandle(thread);
1037 return;
1038 }
1039
1040 test_persistent_connection( si.port );
1041
1042 /* send the basic request again to shutdown the server thread */
1043 test_basic_request( si.port, NULL, quitW );
1044
1045 WaitForSingleObject( thread, 3000 );
1046 CloseHandle( thread );
1047 CloseHandle( server_socket_available );
1048 CloseHandle( server_socket_done );
1049}
thread
static HANDLE thread
Definition: service.c:33
CloseHandle
#define CloseHandle
Definition: compat.h:739
CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
server_thread
static DWORD CALLBACK server_thread(LPVOID param)
Definition: notification.c:644
test_connection_cache
static void test_connection_cache(void)
Definition: notification.c:182
test_basic_request
static void test_basic_request(int port, const WCHAR *verb, const WCHAR *path)
Definition: notification.c:711
test_redirect
static void test_redirect(void)
Definition: notification.c:422
test_async
static void test_async(void)
Definition: notification.c:502
test_persistent_connection
static void test_persistent_connection(int port)
Definition: notification.c:949
CreateEventW
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
WAIT_OBJECT_0
#define WAIT_OBJECT_0
Definition: winbase.h:432

◆ test_async()

static void test_async ( void  )
static

Definition at line 502 of file notification.c.

503{
504 HANDLE ses, con, req, event;
505 DWORD size, status, err;
506 BOOL ret, unload = TRUE;
507 struct info info, *context = &info;
508 char buffer[1024];
509
510 info.test = async_test;
511 info.count = ARRAY_SIZE( async_test );
512 info.index = 0;
513 info.wait = CreateEventW( NULL, FALSE, FALSE, NULL );
514
515 ses = WinHttpOpen( user_agent, 0, NULL, NULL, WINHTTP_FLAG_ASYNC );
516 ok(ses != NULL, "failed to open session %u\n", GetLastError());
517
518 event = CreateEventW( NULL, FALSE, FALSE, NULL );
519 ret = WinHttpSetOption( ses, WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT, &event, sizeof(event) );
520 if (!ret)
521 {
522 win_skip("Unload event not supported\n");
523 unload = FALSE;
524 }
525
526 SetLastError( 0xdeadbeef );
527 WinHttpSetStatusCallback( ses, check_notification, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS, 0 );
528 err = GetLastError();
529 ok(err == ERROR_SUCCESS || broken(err == 0xdeadbeef) /* < win7 */, "got %u\n", err);
530
531 SetLastError( 0xdeadbeef );
532 ret = WinHttpSetOption( ses, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
533 err = GetLastError();
534 ok(ret, "failed to set context value %u\n", err);
535 ok(err == ERROR_SUCCESS || broken(err == 0xdeadbeef) /* < win7 */, "got %u\n", err);
536
537 setup_test( &info, winhttp_connect, __LINE__ );
538 SetLastError( 0xdeadbeef );
539 con = WinHttpConnect( ses, test_winehq, 0, 0 );
540 err = GetLastError();
541 ok(con != NULL, "failed to open a connection %u\n", err);
542 ok(err == ERROR_SUCCESS || broken(err == WSAEINVAL) /* < win7 */, "got %u\n", err);
543
544 setup_test( &info, winhttp_open_request, __LINE__ );
545 SetLastError( 0xdeadbeef );
546 req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
547 err = GetLastError();
548 ok(req != NULL, "failed to open a request %u\n", err);
549 ok(err == ERROR_SUCCESS, "got %u\n", err);
550
551 setup_test( &info, winhttp_send_request, __LINE__ );
552 SetLastError( 0xdeadbeef );
553 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
554 err = GetLastError();
555 if (!ret && (err == ERROR_WINHTTP_CANNOT_CONNECT || err == ERROR_WINHTTP_TIMEOUT))
556 {
557 skip("connection failed, skipping\n");
558 WinHttpCloseHandle( req );
559 WinHttpCloseHandle( con );
560 WinHttpCloseHandle( ses );
561 CloseHandle( info.wait );
562 return;
563 }
564 ok(ret, "failed to send request %u\n", err);
565 ok(err == ERROR_SUCCESS, "got %u\n", err);
566
567 WaitForSingleObject( info.wait, INFINITE );
568
569 setup_test( &info, winhttp_receive_response, __LINE__ );
570 SetLastError( 0xdeadbeef );
571 ret = WinHttpReceiveResponse( req, NULL );
572 err = GetLastError();
573 ok(ret, "failed to receive response %u\n", err);
574 ok(err == ERROR_SUCCESS, "got %u\n", err);
575
576 WaitForSingleObject( info.wait, INFINITE );
577
578 size = sizeof(status);
579 SetLastError( 0xdeadbeef );
580 ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL );
581 err = GetLastError();
582 ok(ret, "failed unexpectedly %u\n", err);
583 ok(status == 200, "request failed unexpectedly %u\n", status);
584 ok(err == ERROR_SUCCESS || broken(err == 0xdeadbeef) /* < win7 */, "got %u\n", err);
585
586 setup_test( &info, winhttp_query_data, __LINE__ );
587 SetLastError( 0xdeadbeef );
588 ret = WinHttpQueryDataAvailable( req, NULL );
589 err = GetLastError();
590 ok(ret, "failed to query data available %u\n", err);
591 ok(err == ERROR_SUCCESS || err == ERROR_IO_PENDING || broken(err == 0xdeadbeef) /* < win7 */, "got %u\n", err);
592
593 WaitForSingleObject( info.wait, INFINITE );
594
595 setup_test( &info, winhttp_read_data, __LINE__ );
596 ret = WinHttpReadData( req, buffer, sizeof(buffer), NULL );
597 ok(ret, "failed to read data %u\n", err);
598
599 WaitForSingleObject( info.wait, INFINITE );
600
601 setup_test( &info, winhttp_close_handle, __LINE__ );
602 WinHttpCloseHandle( req );
603 WinHttpCloseHandle( con );
604
605 if (unload)
606 {
607 status = WaitForSingleObject( event, 0 );
608 ok(status == WAIT_TIMEOUT, "got %08x\n", status);
609 }
610 WinHttpCloseHandle( ses );
611 WaitForSingleObject( info.wait, INFINITE );
612 end_test( &info, __LINE__ );
613
614 if (unload)
615 {
616 status = WaitForSingleObject( event, 2000 );
617 ok(status == WAIT_OBJECT_0, "got %08x\n", status);
618 }
619 CloseHandle( event );
620 CloseHandle( info.wait );
621 end_test( &info, __LINE__ );
622}
skip
#define skip(...)
Definition: atltest.h:64
broken
#define broken(x)
Definition: atltest.h:178
WAIT_TIMEOUT
#define WAIT_TIMEOUT
Definition: dderror.h:14
ERROR_IO_PENDING
#define ERROR_IO_PENDING
Definition: dderror.h:15
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
TRUE
#define TRUE
Definition: types.h:120
SetLastError
#define SetLastError(x)
Definition: compat.h:752
event
struct _cl_event * event
Definition: glext.h:7739
async_test
static const struct notification async_test[]
Definition: notification.c:479
test_winehq
static const WCHAR test_winehq[]
Definition: notification.c:32
tests_hello_html
static const WCHAR tests_hello_html[]
Definition: notification.c:33
err
#define err(...)
Definition: reactos_support_code.h:30
WinHttpQueryHeaders
BOOL WINAPI WinHttpQueryHeaders(HINTERNET hrequest, DWORD level, LPCWSTR name, LPVOID buffer, LPDWORD buflen, LPDWORD index)
Definition: request.c:856
WinHttpQueryDataAvailable
BOOL WINAPI WinHttpQueryDataAvailable(HINTERNET hrequest, LPDWORD available)
Definition: request.c:3005
win_skip
#define win_skip
Definition: test.h:163
WSAEINVAL
#define WSAEINVAL
Definition: winerror.h:1946
WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT
#define WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT
Definition: winhttp.h:141
ERROR_WINHTTP_CANNOT_CONNECT
#define ERROR_WINHTTP_CANNOT_CONNECT
Definition: winhttp.h:201
WINHTTP_QUERY_STATUS_CODE
#define WINHTTP_QUERY_STATUS_CODE
Definition: winhttp.h:317
WINHTTP_QUERY_FLAG_NUMBER
#define WINHTTP_QUERY_FLAG_NUMBER
Definition: winhttp.h:377
ERROR_WINHTTP_TIMEOUT
#define ERROR_WINHTTP_TIMEOUT
Definition: winhttp.h:189

Referenced by START_TEST().

◆ test_basic_request()

static void test_basic_request ( int  port,
const WCHAR *  verb,
const WCHAR *  path 
)
static

Definition at line 711 of file notification.c.

712{
713 HINTERNET ses, con, req;
714 char buffer[0x100];
715 DWORD count, status, size;
716 BOOL ret;
717
718 ses = WinHttpOpen(NULL, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0);
719 ok(ses != NULL, "failed to open session %u\n", GetLastError());
720
721 con = WinHttpConnect(ses, localhostW, port, 0);
722 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
723
724 req = WinHttpOpenRequest(con, verb, path, NULL, NULL, NULL, 0);
725 ok(req != NULL, "failed to open a request %u\n", GetLastError());
726
727 ret = WinHttpSendRequest(req, NULL, 0, NULL, 0, 0, 0);
728 ok(ret, "failed to send request %u\n", GetLastError());
729
730 ret = WinHttpReceiveResponse(req, NULL);
731 ok(ret, "failed to receive response %u\n", GetLastError());
732
733 status = 0xdeadbeef;
734 size = sizeof(status);
735 ret = WinHttpQueryHeaders(req, WINHTTP_QUERY_STATUS_CODE|WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL);
736 ok(ret, "failed to query status code %u\n", GetLastError());
737 ok(status == HTTP_STATUS_OK, "request failed unexpectedly %u\n", status);
738
739 count = 0;
740 memset(buffer, 0, sizeof(buffer));
741 ret = WinHttpReadData(req, buffer, sizeof buffer, &count);
742 ok(ret, "failed to read data %u\n", GetLastError());
743 ok(count == sizeof page1 - 1, "count was wrong\n");
744 ok(!memcmp(buffer, page1, sizeof page1), "http data wrong\n");
745
746 WinHttpCloseHandle(req);
747 WinHttpCloseHandle(con);
748 WinHttpCloseHandle(ses);
749}
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
HTTP_STATUS_OK
#define HTTP_STATUS_OK
Definition: winhttp.h:240
WINHTTP_ACCESS_TYPE_NO_PROXY
#define WINHTTP_ACCESS_TYPE_NO_PROXY
Definition: winhttp.h:63

Referenced by START_TEST().

◆ test_connection_cache()

static void test_connection_cache ( void  )
static

Definition at line 182 of file notification.c.

183{
184 HANDLE ses, con, req, event;
185 DWORD size, status, err;
186 BOOL ret, unload = TRUE;
187 struct info info, *context = &info;
188
189 info.test = cache_test;
190 info.count = ARRAY_SIZE( cache_test );
191 info.index = 0;
192 info.wait = CreateEventW( NULL, FALSE, FALSE, NULL );
193
194 ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 );
195 ok(ses != NULL, "failed to open session %u\n", GetLastError());
196
197 event = CreateEventW( NULL, FALSE, FALSE, NULL );
198 ret = WinHttpSetOption( ses, WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT, &event, sizeof(event) );
199 if (!ret)
200 {
201 win_skip("Unload event not supported\n");
202 unload = FALSE;
203 }
204
205 WinHttpSetStatusCallback( ses, check_notification, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS, 0 );
206
207 ret = WinHttpSetOption( ses, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
208 ok(ret, "failed to set context value %u\n", GetLastError());
209
210 setup_test( &info, winhttp_connect, __LINE__ );
211 con = WinHttpConnect( ses, test_winehq, 0, 0 );
212 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
213
214 setup_test( &info, winhttp_open_request, __LINE__ );
215 req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
216 ok(req != NULL, "failed to open a request %u\n", GetLastError());
217
218 setup_test( &info, winhttp_send_request, __LINE__ );
219 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
220 err = GetLastError();
221 if (!ret && (err == ERROR_WINHTTP_CANNOT_CONNECT || err == ERROR_WINHTTP_TIMEOUT))
222 {
223 skip("connection failed, skipping\n");
224 goto done;
225 }
226 ok(ret, "failed to send request %u\n", GetLastError());
227
228 setup_test( &info, winhttp_receive_response, __LINE__ );
229 ret = WinHttpReceiveResponse( req, NULL );
230 ok(ret, "failed to receive response %u\n", GetLastError());
231
232 size = sizeof(status);
233 ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL );
234 ok(ret, "failed unexpectedly %u\n", GetLastError());
235 ok(status == 200, "request failed unexpectedly %u\n", status);
236
237 ResetEvent( info.wait );
238 setup_test( &info, winhttp_close_handle, __LINE__ );
239 WinHttpCloseHandle( req );
240 WaitForSingleObject( info.wait, INFINITE );
241
242 setup_test( &info, winhttp_open_request, __LINE__ );
243 req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
244 ok(req != NULL, "failed to open a request %u\n", GetLastError());
245
246 ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
247 ok(ret, "failed to set context value %u\n", GetLastError());
248
249 setup_test( &info, winhttp_send_request, __LINE__ );
250 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
251 err = GetLastError();
252 if (!ret && (err == ERROR_WINHTTP_CANNOT_CONNECT || err == ERROR_WINHTTP_TIMEOUT))
253 {
254 skip("connection failed, skipping\n");
255 goto done;
256 }
257 ok(ret, "failed to send request %u\n", GetLastError());
258
259 setup_test( &info, winhttp_receive_response, __LINE__ );
260 ret = WinHttpReceiveResponse( req, NULL );
261 ok(ret, "failed to receive response %u\n", GetLastError());
262
263 size = sizeof(status);
264 ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL );
265 ok(ret, "failed unexpectedly %u\n", GetLastError());
266 ok(status == 200, "request failed unexpectedly %u\n", status);
267
268 ResetEvent( info.wait );
269 setup_test( &info, winhttp_close_handle, __LINE__ );
270 WinHttpCloseHandle( req );
271 WinHttpCloseHandle( req );
272 WinHttpCloseHandle( con );
273 WaitForSingleObject( info.wait, INFINITE );
274
275 if (unload)
276 {
277 status = WaitForSingleObject( event, 0 );
278 ok(status == WAIT_TIMEOUT, "got %08x\n", status);
279 }
280
281 setup_test( &info, winhttp_close_handle, __LINE__ );
282 WinHttpCloseHandle( ses );
283 WaitForSingleObject( info.wait, INFINITE );
284
285 if (unload)
286 {
287 status = WaitForSingleObject( event, 100 );
288 ok(status == WAIT_OBJECT_0, "got %08x\n", status);
289 }
290
291
292 ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 );
293 ok(ses != NULL, "failed to open session %u\n", GetLastError());
294
295 if (unload)
296 {
297 ret = WinHttpSetOption( ses, WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT, &event, sizeof(event) );
298 ok(ret, "failed to set unload option\n");
299 }
300
301 WinHttpSetStatusCallback( ses, check_notification, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS, 0 );
302
303 ret = WinHttpSetOption( ses, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
304 ok(ret, "failed to set context value %u\n", GetLastError());
305
306 setup_test( &info, winhttp_connect, __LINE__ );
307 con = WinHttpConnect( ses, test_winehq, 0, 0 );
308 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
309
310 setup_test( &info, winhttp_open_request, __LINE__ );
311 req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
312 ok(req != NULL, "failed to open a request %u\n", GetLastError());
313
314 ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
315 ok(ret, "failed to set context value %u\n", GetLastError());
316
317 setup_test( &info, winhttp_send_request, __LINE__ );
318 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
319 err = GetLastError();
320 if (!ret && (err == ERROR_WINHTTP_CANNOT_CONNECT || err == ERROR_WINHTTP_TIMEOUT))
321 {
322 skip("connection failed, skipping\n");
323 goto done;
324 }
325 ok(ret, "failed to send request %u\n", GetLastError());
326
327 setup_test( &info, winhttp_receive_response, __LINE__ );
328 ret = WinHttpReceiveResponse( req, NULL );
329 ok(ret, "failed to receive response %u\n", GetLastError());
330
331 size = sizeof(status);
332 ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL );
333 ok(ret, "failed unexpectedly %u\n", GetLastError());
334 ok(status == 200, "request failed unexpectedly %u\n", status);
335
336 ResetEvent( info.wait );
337 setup_test( &info, winhttp_close_handle, __LINE__ );
338 WinHttpCloseHandle( req );
339 WaitForSingleObject( info.wait, INFINITE );
340
341 setup_test( &info, winhttp_open_request, __LINE__ );
342 req = WinHttpOpenRequest( con, NULL, tests_hello_html, NULL, NULL, NULL, 0 );
343 ok(req != NULL, "failed to open a request %u\n", GetLastError());
344
345 ret = WinHttpSetOption( req, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
346 ok(ret, "failed to set context value %u\n", GetLastError());
347
348 setup_test( &info, winhttp_send_request, __LINE__ );
349 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
350 err = GetLastError();
351 if (!ret && (err == ERROR_WINHTTP_CANNOT_CONNECT || err == ERROR_WINHTTP_TIMEOUT))
352 {
353 skip("connection failed, skipping\n");
354 goto done;
355 }
356 ok(ret, "failed to send request %u\n", GetLastError());
357
358 setup_test( &info, winhttp_receive_response, __LINE__ );
359 ret = WinHttpReceiveResponse( req, NULL );
360 ok(ret, "failed to receive response %u\n", GetLastError());
361
362 size = sizeof(status);
363 ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL );
364 ok(ret, "failed unexpectedly %u\n", GetLastError());
365 ok(status == 200, "request failed unexpectedly %u\n", status);
366
367 setup_test( &info, winhttp_close_handle, __LINE__ );
368done:
369 WinHttpCloseHandle( req );
370 WinHttpCloseHandle( con );
371 WaitForSingleObject( info.wait, INFINITE );
372
373 if (unload)
374 {
375 status = WaitForSingleObject( event, 0 );
376 ok(status == WAIT_TIMEOUT, "got %08x\n", status);
377 }
378
379 setup_test( &info, winhttp_close_handle, __LINE__ );
380 WinHttpCloseHandle( ses );
381 WaitForSingleObject( info.wait, INFINITE );
382 CloseHandle( info.wait );
383 end_test( &info, __LINE__ );
384
385 if (unload)
386 {
387 status = WaitForSingleObject( event, 100 );
388 ok(status == WAIT_OBJECT_0, "got %08x\n", status);
389 }
390
391 CloseHandle( event );
392}
cache_test
static const struct notification cache_test[]
Definition: notification.c:109

Referenced by START_TEST().

◆ test_persistent_connection()

static void test_persistent_connection ( int  port)
static

Definition at line 949 of file notification.c.

950{
951 struct test_request req;
952 struct info info;
953
954 static const WCHAR testW[] = {'/','t','e','s','t',0};
955
956 trace("Testing persistent connection...\n");
957
958 info.wait = CreateEventW( NULL, FALSE, FALSE, NULL );
959
960 open_socket_request( port, &req, &info );
961 server_send_reply( &req, &info,
962 "HTTP/1.1 200 OK\r\n"
963 "Server: winetest\r\n"
964 "Connection: keep-alive\r\n"
965 "Content-Length: 1\r\n"
966 "\r\n"
967 "X" );
968 read_request_data( &req, &info, "X", FALSE );
969 close_request( &req, &info, FALSE );
970
971 /* chunked connection test */
972 open_async_request( port, &req, &info, testW, TRUE );
973 server_read_data( "GET /test HTTP/1.1\r\n" );
974 server_send_reply( &req, &info,
975 "HTTP/1.1 200 OK\r\n"
976 "Server: winetest\r\n"
977 "Transfer-Encoding: chunked\r\n"
978 "Connection: keep-alive\r\n"
979 "\r\n"
980 "9\r\n123456789\r\n"
981 "0\r\n\r\n" );
982 read_request_data( &req, &info, "123456789", FALSE );
983 close_request( &req, &info, FALSE );
984
985 /* HTTP/1.1 connections are persistent by default, no additional header is needed */
986 open_async_request( port, &req, &info, testW, TRUE );
987 server_read_data( "GET /test HTTP/1.1\r\n" );
988 server_send_reply( &req, &info,
989 "HTTP/1.1 200 OK\r\n"
990 "Server: winetest\r\n"
991 "Content-Length: 2\r\n"
992 "\r\n"
993 "xx" );
994 read_request_data( &req, &info, "xx", FALSE );
995 close_request( &req, &info, FALSE );
996
997 open_async_request( port, &req, &info, testW, TRUE );
998 server_read_data( "GET /test HTTP/1.1\r\n" );
999 server_send_reply( &req, &info,
1000 "HTTP/1.1 200 OK\r\n"
1001 "Server: winetest\r\n"
1002 "Content-Length: 2\r\n"
1003 "Connection: close\r\n"
1004 "\r\n"
1005 "yy" );
1006 close_request( &req, &info, TRUE );
1007
1008 SetEvent( server_socket_done );
1009 CloseHandle( info.wait );
1010}
trace
#define trace
Definition: atltest.h:70
testW
static const WCHAR testW[]
Definition: jsregexp.c:44
close_request
#define close_request(a)
Definition: http.c:547
server_read_data
#define server_read_data(a)
Definition: notification.c:843
read_request_data
#define read_request_data(a, b, c, d)
Definition: notification.c:919
open_socket_request
static void open_socket_request(int port, struct test_request *req, struct info *info)
Definition: notification.c:809
server_send_reply
static void server_send_reply(struct test_request *req, struct info *info, const char *msg)
Definition: notification.c:825
test_request
Definition: notification.c:71

Referenced by START_TEST().

◆ test_redirect()

static void test_redirect ( void  )
static

Definition at line 422 of file notification.c.

423{
424 HANDLE ses, con, req;
425 DWORD size, status, err;
426 BOOL ret;
427 struct info info, *context = &info;
428
429 info.test = redirect_test;
430 info.count = ARRAY_SIZE( redirect_test );
431 info.index = 0;
432 info.wait = CreateEventW( NULL, FALSE, FALSE, NULL );
433
434 ses = WinHttpOpen( user_agent, 0, NULL, NULL, 0 );
435 ok(ses != NULL, "failed to open session %u\n", GetLastError());
436
437 WinHttpSetStatusCallback( ses, check_notification, WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS, 0 );
438
439 ret = WinHttpSetOption( ses, WINHTTP_OPTION_CONTEXT_VALUE, &context, sizeof(struct info *) );
440 ok(ret, "failed to set context value %u\n", GetLastError());
441
442 setup_test( &info, winhttp_connect, __LINE__ );
443 con = WinHttpConnect( ses, test_winehq, 0, 0 );
444 ok(con != NULL, "failed to open a connection %u\n", GetLastError());
445
446 setup_test( &info, winhttp_open_request, __LINE__ );
447 req = WinHttpOpenRequest( con, NULL, tests_redirect, NULL, NULL, NULL, 0 );
448 ok(req != NULL, "failed to open a request %u\n", GetLastError());
449
450 setup_test( &info, winhttp_send_request, __LINE__ );
451 ret = WinHttpSendRequest( req, NULL, 0, NULL, 0, 0, 0 );
452 err = GetLastError();
453 if (!ret && (err == ERROR_WINHTTP_CANNOT_CONNECT || err == ERROR_WINHTTP_TIMEOUT))
454 {
455 skip("connection failed, skipping\n");
456 goto done;
457 }
458 ok(ret, "failed to send request %u\n", GetLastError());
459
460 setup_test( &info, winhttp_receive_response, __LINE__ );
461 ret = WinHttpReceiveResponse( req, NULL );
462 ok(ret, "failed to receive response %u\n", GetLastError());
463
464 size = sizeof(status);
465 ret = WinHttpQueryHeaders( req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &size, NULL );
466 ok(ret, "failed unexpectedly %u\n", GetLastError());
467 ok(status == 200, "request failed unexpectedly %u\n", status);
468
469 setup_test( &info, winhttp_close_handle, __LINE__ );
470done:
471 WinHttpCloseHandle( req );
472 WinHttpCloseHandle( con );
473 WinHttpCloseHandle( ses );
474 WaitForSingleObject( info.wait, INFINITE );
475 CloseHandle( info.wait );
476 end_test( &info, __LINE__ );
477}
redirect_test
static const struct notification redirect_test[]
Definition: notification.c:394
tests_redirect
static const WCHAR tests_redirect[]
Definition: notification.c:34

Referenced by START_TEST().

Variable Documentation

◆ async_test

const struct notification async_test[]
static
Initial value:
=
{
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NF_SIGNAL },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NF_SIGNAL },
{ winhttp_query_data, WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE, NF_SIGNAL },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, NF_SIGNAL },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
}
WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED
#define WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED
Definition: winhttp.h:387
WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE
#define WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE
Definition: winhttp.h:397
WINHTTP_CALLBACK_STATUS_SENDING_REQUEST
#define WINHTTP_CALLBACK_STATUS_SENDING_REQUEST
Definition: winhttp.h:384
WINHTTP_CALLBACK_STATUS_REQUEST_SENT
#define WINHTTP_CALLBACK_STATUS_REQUEST_SENT
Definition: winhttp.h:385
WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE
#define WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE
Definition: winhttp.h:396
WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE
#define WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE
Definition: winhttp.h:386
WINHTTP_CALLBACK_STATUS_READ_COMPLETE
#define WINHTTP_CALLBACK_STATUS_READ_COMPLETE
Definition: winhttp.h:398
WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING
#define WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING
Definition: winhttp.h:391
WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER
#define WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER
Definition: winhttp.h:382
WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER
#define WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER
Definition: winhttp.h:383
WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE
#define WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE
Definition: winhttp.h:401
WINHTTP_CALLBACK_STATUS_RESOLVING_NAME
#define WINHTTP_CALLBACK_STATUS_RESOLVING_NAME
Definition: winhttp.h:380
WINHTTP_CALLBACK_STATUS_NAME_RESOLVED
#define WINHTTP_CALLBACK_STATUS_NAME_RESOLVED
Definition: winhttp.h:381

Definition at line 479 of file notification.c.

Referenced by test_async().

◆ cache_test

const struct notification cache_test[]
static

Definition at line 109 of file notification.c.

Referenced by test_connection_cache().

◆ close_allow_connection_close_request_test

const struct notification close_allow_connection_close_request_test[]
static
Initial value:
=
{
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
}
WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION
#define WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION
Definition: winhttp.h:388
WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED
#define WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED
Definition: winhttp.h:389

Definition at line 866 of file notification.c.

Referenced by close_request().

◆ close_request_test

const struct notification close_request_test[]
static
Initial value:
=
{
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
}

Definition at line 859 of file notification.c.

Referenced by close_request().

◆ localhostW

const WCHAR localhostW[] = {'l','o','c','a','l','h','o','s','t',0}
static

Definition at line 35 of file notification.c.

Referenced by canonicalize_reg_name(), is_local_machine(), open_async_request(), test_basic_request(), and test_CertRDNValueToStrW().

◆ okmsg

const char okmsg[]
static
Initial value:
=
"HTTP/1.1 200 OK\r\n"
"Server: winetest\r\n"
"\r\n"

Definition at line 624 of file notification.c.

Referenced by server_thread().

◆ open_socket_request_test

const struct notification open_socket_request_test[]
static
Initial value:
=
{
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NF_SIGNAL }
}

Definition at line 751 of file notification.c.

Referenced by open_async_request().

◆ page1

const char page1[]
static
Initial value:
=
"<HTML>\r\n"
"<HEAD><TITLE>winhttp test page</TITLE></HEAD>\r\n"
"<BODY>The quick brown fox jumped over the lazy dog<P></BODY>\r\n"
"</HTML>\r\n\r\n"

Definition at line 629 of file notification.c.

Referenced by server_thread(), and test_basic_request().

◆ read_allow_close_test

const struct notification read_allow_close_test[]
static
Initial value:
=
{
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, NF_SIGNAL }
}

Definition at line 910 of file notification.c.

Referenced by _read_request_data().

◆ read_test

const struct notification read_test[]
static
Initial value:
=
{
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, NF_ALLOW },
{ winhttp_read_data, WINHTTP_CALLBACK_STATUS_READ_COMPLETE, NF_SIGNAL }
}

Definition at line 903 of file notification.c.

Referenced by _read_request_data(), and test_file().

◆ redirect_test

const struct notification redirect_test[]
static
Initial value:
=
{
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_WINE_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_REDIRECT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESOLVING_NAME, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_NAME_RESOLVED, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER, NF_ALLOW },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE },
{ winhttp_receive_response, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED, NF_WINE_ALLOW },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING },
{ winhttp_close_handle, WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING, NF_SIGNAL }
}
WINHTTP_CALLBACK_STATUS_REDIRECT
#define WINHTTP_CALLBACK_STATUS_REDIRECT
Definition: winhttp.h:393

Definition at line 394 of file notification.c.

Referenced by test_redirect().

◆ reuse_socket_request_test

const struct notification reuse_socket_request_test[]
static
Initial value:
=
{
{ winhttp_connect, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_open_request, WINHTTP_CALLBACK_STATUS_HANDLE_CREATED },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDING_REQUEST },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_REQUEST_SENT },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE, NF_SIGNAL },
}

Definition at line 765 of file notification.c.

Referenced by open_async_request().

◆ server_reply_test

const struct notification server_reply_test[]
static
Initial value:
=
{
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE, NF_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED, NF_ALLOW },
{ winhttp_send_request, WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE, NF_SIGNAL }
}

Definition at line 818 of file notification.c.

Referenced by server_send_reply().

◆ server_socket

int server_socket
static

Definition at line 641 of file notification.c.

Referenced by _server_read_data(), server_send_reply(), and server_thread().

◆ server_socket_available

HANDLE server_socket_available
static

Definition at line 642 of file notification.c.

Referenced by open_socket_request(), server_thread(), and START_TEST().

◆ server_socket_done

HANDLE server_socket_done
static

Definition at line 642 of file notification.c.

Referenced by open_socket_request(), server_thread(), START_TEST(), and test_persistent_connection().

◆ test_winehq

const WCHAR test_winehq[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0}
static

Definition at line 32 of file notification.c.

Referenced by test_async(), test_connection_cache(), and test_redirect().

◆ tests_hello_html

const WCHAR tests_hello_html[] = {'/','t','e','s','t','s','/','h','e','l','l','o','.','h','t','m','l',0}
static

Definition at line 33 of file notification.c.

Referenced by test_async(), and test_connection_cache().

◆ tests_redirect

const WCHAR tests_redirect[] = {'/','t','e','s','t','s','/','r','e','d','i','r','e','c','t',0}
static

Definition at line 34 of file notification.c.

Referenced by test_redirect().

◆ user_agent

const WCHAR user_agent[] = {'w','i','n','e','t','e','s','t',0}
static

Definition at line 31 of file notification.c.

Referenced by open_async_request(), test_async(), test_connection_cache(), and test_redirect().