1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*
* win.c
* Release $Name: MATRIXSSL_1_8_8_OPEN $
*
* Microsoft Windows compatibility layer.
*/
/*
* Copyright (c) PeerSec Networks, 2002-2009. All Rights Reserved.
* The latest version of this code is available at http://www.matrixssl.org
*
* This software is open source; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This General Public License does NOT permit incorporating this software
* into proprietary programs. If you are unable to comply with the GPL, a
* commercial license for this software may be purchased from PeerSec Networks
* at http://www.peersec.com
*
* This program is distributed in WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
* http://www.gnu.org/copyleft/gpl.html
*/
/******************************************************************************/
#include "../osLayer.h"
#include <windows.h>
#include <wincrypt.h>
#ifndef WINCE
#include <process.h>
#endif
#include <limits.h>
#if defined(WIN32) || defined(WINCE)
#define MAX_INT 0x7FFFFFFF
static LARGE_INTEGER hiresStart; /* zero-time */
static LARGE_INTEGER hiresFreq; /* tics per second */
/* For backwards compatibility */
#ifndef CRYPT_SILENT
#define CRYPT_SILENT 0
#endif
static HCRYPTPROV hProv; /* Crypto context for random bytes */
int32 sslOpenOsdep()
{
int32 rc;
if ((rc = psOpenMalloc(MAX_MEMORY_USAGE)) < 0) {
return rc;
}
/*
Hires time init
*/
QueryPerformanceFrequency(&hiresFreq);
QueryPerformanceCounter(&hiresStart);
if (!CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT)) {
return -1;
}
return 0;
}
int32 sslCloseOsdep()
{
CryptReleaseContext(hProv, 0);
psCloseMalloc();
return 0;
}
int32 sslGetEntropy(unsigned char *bytes, int32 size)
{
if (CryptGenRandom(hProv, size, bytes)) {
return size;
}
return -1;
}
#ifdef DEBUG
void psBreak()
{
int32 i = 0; i++; /* Prevent the compiler optimizing this function away */
DebugBreak();
}
#endif
int32 sslInitMsecs(sslTime_t *t)
{
__int64 diff;
int32 d;
QueryPerformanceCounter(t);
diff = t->QuadPart - hiresStart.QuadPart;
d = (int32)((diff * 1000) / hiresFreq.QuadPart);
return d;
}
int32 sslDiffSecs(sslTime_t then, sslTime_t now)
{
__int64 diff;
diff = now.QuadPart - then.QuadPart;
return (int32)(diff / hiresFreq.QuadPart);
}
/*
Time comparison. 1 if 'a' is less than or equal. 0 if 'a' is greater
*/
int32 sslCompareTime(sslTime_t a, sslTime_t b)
{
if (a.QuadPart <= b.QuadPart) {
return 1;
}
return 0;
}
#ifdef WINCE
/******************************************************************************/
/*
Our implementation of wide character stat: get file information.
NOTES:
only gets the file size currently
*/
int32 stat(char *filename, struct stat *sbuf)
{
DWORD dwAttributes;
HANDLE hFile;
int32 rc, size;
unsigned short uniFile[512];
rc = 0;
memset(sbuf, 0, sizeof(struct stat));
MultiByteToWideChar(CP_ACP, 0, filename, -1, uniFile, 256);
dwAttributes = GetFileAttributes(uniFile);
if (dwAttributes != 0xFFFFFFFF && dwAttributes & FILE_ATTRIBUTE_DIRECTORY) {
sbuf->st_mode = S_IFDIR;
return 0;
}
sbuf->st_mode = S_IFREG;
if ((hFile = CreateFile(uniFile, GENERIC_READ, FILE_SHARE_READ && FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE) {
return -1;
}
/*
* Get the file size.
*/
size = GetFileSize(hFile, NULL);
sbuf->st_size = size;
CloseHandle(hFile);
return rc;
}
/******************************************************************************/
/*
The following functions implement a unixlike time() function.
*/
static FILETIME YearToFileTime(WORD wYear)
{
SYSTEMTIME sbase;
FILETIME fbase;
sbase.wYear = wYear;
sbase.wMonth = 1;
sbase.wDayOfWeek = 1; //assumed
sbase.wDay = 1;
sbase.wHour = 0;
sbase.wMinute = 0;
sbase.wSecond = 0;
sbase.wMilliseconds = 0;
SystemTimeToFileTime( &sbase, &fbase );
return fbase;
}
time_t time() {
__int64 time1, time2, iTimeDiff;
FILETIME fileTime1, fileTime2;
SYSTEMTIME sysTime;
/*
Get 1970's filetime.
*/
fileTime1 = YearToFileTime(1970);
/*
Get the current filetime time.
*/
GetSystemTime(&sysTime);
SystemTimeToFileTime(&sysTime, &fileTime2);
/*
Stuff the 2 FILETIMEs into their own __int64s.
*/
time1 = fileTime1.dwHighDateTime;
time1 <<= 32;
time1 |= fileTime1.dwLowDateTime;
time2 = fileTime2.dwHighDateTime;
time2 <<= 32;
time2 |= fileTime2.dwLowDateTime;
/*
Get the difference of the two64-bit ints.
This is he number of 100-nanosecond intervals since Jan. 1970. So
we divide by 10000 to get seconds.
*/
iTimeDiff = (time2 - time1) / 10000000;
return (int32)iTimeDiff;
}
#endif /* WINCE */
#endif /* WIN32 */
/******************************************************************************/
|
