← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to src/pkg/syscall/syscall_windows.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-08-03 17:04:59 UTC
  • mfrom: (14.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20110803170459-wzd99m3567y80ila
Tags: 1:59-1
http://bugs.debian.org/634270
* Imported Upstream version 59
* Refresh patches to a new release
* Fix FTBFS on ARM (Closes: #634270)
* Update version.bash to work with Debian packaging and not hg
  repository

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/syscall/syscall_windows.go
13
13
 
14
14
const OS = "windows"
15
15
 
 
16
type Handle uintptr
 
17
 
 
18
const InvalidHandle = ^Handle(0)
 
19
 
16
20
/*
17
21
 
18
22
small demo to detect version of windows you are running:
77
81
func Syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)
78
82
func Syscall9(trap, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr)
79
83
func Syscall12(trap, nargs, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12 uintptr) (r1, r2, err uintptr)
80
 
func loadlibraryex(filename uintptr) (handle uint32)
81
 
func getprocaddress(handle uint32, procname uintptr) (proc uintptr)
 
84
func loadlibraryex(filename uintptr) (handle uintptr)
 
85
func getprocaddress(handle uintptr, procname uintptr) (proc uintptr)
82
86
 
83
 
func loadDll(fname string) uint32 {
 
87
func loadDll(fname string) uintptr {
84
88
        m := loadlibraryex(uintptr(unsafe.Pointer(StringBytePtr(fname))))
85
89
        if m == 0 {
86
90
                panic("syscall: could not LoadLibraryEx " + fname)
88
92
        return m
89
93
}
90
94
 
91
 
func getSysProcAddr(m uint32, pname string) uintptr {
 
95
func getSysProcAddr(m uintptr, pname string) uintptr {
92
96
        p := getprocaddress(m, uintptr(unsafe.Pointer(StringBytePtr(pname))))
93
97
        if p == 0 {
94
98
                panic("syscall: could not GetProcAddress for " + pname)
96
100
        return p
97
101
}
98
102
 
 
103
func Getpagesize() int { return 4096 }
 
104
 
99
105
// Converts a Go function to a function pointer conforming
100
106
// to the stdcall calling convention.  This is useful when
101
107
// interoperating with Windows code requiring callbacks.
110
116
// windows api calls
111
117
 
112
118
//sys   GetLastError() (lasterrno int)
113
 
//sys   LoadLibrary(libname string) (handle uint32, errno int) = LoadLibraryW
114
 
//sys   FreeLibrary(handle uint32) (errno int)
115
 
//sys   GetProcAddress(module uint32, procname string) (proc uint32, errno int)
 
119
//sys   LoadLibrary(libname string) (handle Handle, errno int) = LoadLibraryW
 
120
//sys   FreeLibrary(handle Handle) (errno int)
 
121
//sys   GetProcAddress(module Handle, procname string) (proc Handle, errno int)
116
122
//sys   GetVersion() (ver uint32, errno int)
117
123
//sys   FormatMessage(flags uint32, msgsrc uint32, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, errno int) = FormatMessageW
118
124
//sys   ExitProcess(exitcode uint32)
119
 
//sys   CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile int32) (handle int32, errno int) [failretval==-1] = CreateFileW
120
 
//sys   ReadFile(handle int32, buf []byte, done *uint32, overlapped *Overlapped) (errno int)
121
 
//sys   WriteFile(handle int32, buf []byte, done *uint32, overlapped *Overlapped) (errno int)
122
 
//sys   SetFilePointer(handle int32, lowoffset int32, highoffsetptr *int32, whence uint32) (newlowoffset uint32, errno int) [failretval==0xffffffff]
123
 
//sys   CloseHandle(handle int32) (errno int)
124
 
//sys   GetStdHandle(stdhandle int32) (handle int32, errno int) [failretval==-1]
125
 
//sys   FindFirstFile(name *uint16, data *Win32finddata) (handle int32, errno int) [failretval==-1] = FindFirstFileW
126
 
//sys   FindNextFile(handle int32, data *Win32finddata) (errno int) = FindNextFileW
127
 
//sys   FindClose(handle int32) (errno int)
128
 
//sys   GetFileInformationByHandle(handle int32, data *ByHandleFileInformation) (errno int)
 
125
//sys   CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile int32) (handle Handle, errno int) [failretval==InvalidHandle] = CreateFileW
 
126
//sys   ReadFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (errno int)
 
127
//sys   WriteFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (errno int)
 
128
//sys   SetFilePointer(handle Handle, lowoffset int32, highoffsetptr *int32, whence uint32) (newlowoffset uint32, errno int) [failretval==0xffffffff]
 
129
//sys   CloseHandle(handle Handle) (errno int)
 
130
//sys   GetStdHandle(stdhandle int) (handle Handle, errno int) [failretval==InvalidHandle]
 
131
//sys   FindFirstFile(name *uint16, data *Win32finddata) (handle Handle, errno int) [failretval==InvalidHandle] = FindFirstFileW
 
132
//sys   FindNextFile(handle Handle, data *Win32finddata) (errno int) = FindNextFileW
 
133
//sys   FindClose(handle Handle) (errno int)
 
134
//sys   GetFileInformationByHandle(handle Handle, data *ByHandleFileInformation) (errno int)
129
135
//sys   GetCurrentDirectory(buflen uint32, buf *uint16) (n uint32, errno int) = GetCurrentDirectoryW
130
136
//sys   SetCurrentDirectory(path *uint16) (errno int) = SetCurrentDirectoryW
131
137
//sys   CreateDirectory(path *uint16, sa *SecurityAttributes) (errno int) = CreateDirectoryW
133
139
//sys   DeleteFile(path *uint16) (errno int) = DeleteFileW
134
140
//sys   MoveFile(from *uint16, to *uint16) (errno int) = MoveFileW
135
141
//sys   GetComputerName(buf *uint16, n *uint32) (errno int) = GetComputerNameW
136
 
//sys   SetEndOfFile(handle int32) (errno int)
 
142
//sys   SetEndOfFile(handle Handle) (errno int)
137
143
//sys   GetSystemTimeAsFileTime(time *Filetime)
138
144
//sys   sleep(msec uint32) = Sleep
139
145
//sys   GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, errno int) [failretval==0xffffffff]
140
 
//sys   CreateIoCompletionPort(filehandle int32, cphandle int32, key uint32, threadcnt uint32) (handle int32, errno int)
141
 
//sys   GetQueuedCompletionStatus(cphandle int32, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (errno int)
142
 
//sys   CancelIo(s uint32) (errno int)
 
146
//sys   CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, errno int)
 
147
//sys   GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (errno int)
 
148
//sys   CancelIo(s Handle) (errno int)
143
149
//sys   CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (errno int) = CreateProcessW
144
 
//sys   OpenProcess(da uint32, inheritHandle bool, pid uint32) (handle int32, errno int)
145
 
//sys   TerminateProcess(handle int32, exitcode uint32) (errno int)
146
 
//sys   GetExitCodeProcess(handle int32, exitcode *uint32) (errno int)
 
150
//sys   OpenProcess(da uint32, inheritHandle bool, pid uint32) (handle Handle, errno int)
 
151
//sys   TerminateProcess(handle Handle, exitcode uint32) (errno int)
 
152
//sys   GetExitCodeProcess(handle Handle, exitcode *uint32) (errno int)
147
153
//sys   GetStartupInfo(startupInfo *StartupInfo) (errno int) = GetStartupInfoW
148
 
//sys   GetCurrentProcess() (pseudoHandle int32, errno int)
149
 
//sys   DuplicateHandle(hSourceProcessHandle int32, hSourceHandle int32, hTargetProcessHandle int32, lpTargetHandle *int32, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (errno int)
150
 
//sys   WaitForSingleObject(handle int32, waitMilliseconds uint32) (event uint32, errno int) [failretval==0xffffffff]
 
154
//sys   GetCurrentProcess() (pseudoHandle Handle, errno int)
 
155
//sys   DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (errno int)
 
156
//sys   WaitForSingleObject(handle Handle, waitMilliseconds uint32) (event uint32, errno int) [failretval==0xffffffff]
151
157
//sys   GetTempPath(buflen uint32, buf *uint16) (n uint32, errno int) = GetTempPathW
152
 
//sys   CreatePipe(readhandle *uint32, writehandle *uint32, sa *SecurityAttributes, size uint32) (errno int)
153
 
//sys   GetFileType(filehandle uint32) (n uint32, errno int)
154
 
//sys   CryptAcquireContext(provhandle *uint32, container *uint16, provider *uint16, provtype uint32, flags uint32) (errno int) = advapi32.CryptAcquireContextW
155
 
//sys   CryptReleaseContext(provhandle uint32, flags uint32) (errno int) = advapi32.CryptReleaseContext
156
 
//sys   CryptGenRandom(provhandle uint32, buflen uint32, buf *byte) (errno int) = advapi32.CryptGenRandom
 
158
//sys   CreatePipe(readhandle *Handle, writehandle *Handle, sa *SecurityAttributes, size uint32) (errno int)
 
159
//sys   GetFileType(filehandle Handle) (n uint32, errno int)
 
160
//sys   CryptAcquireContext(provhandle *Handle, container *uint16, provider *uint16, provtype uint32, flags uint32) (errno int) = advapi32.CryptAcquireContextW
 
161
//sys   CryptReleaseContext(provhandle Handle, flags uint32) (errno int) = advapi32.CryptReleaseContext
 
162
//sys   CryptGenRandom(provhandle Handle, buflen uint32, buf *byte) (errno int) = advapi32.CryptGenRandom
157
163
//sys   GetEnvironmentStrings() (envs *uint16, errno int) [failretval==nil] = kernel32.GetEnvironmentStringsW
158
164
//sys   FreeEnvironmentStrings(envs *uint16) (errno int) = kernel32.FreeEnvironmentStringsW
159
165
//sys   GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, errno int) = kernel32.GetEnvironmentVariableW
160
166
//sys   SetEnvironmentVariable(name *uint16, value *uint16) (errno int) = kernel32.SetEnvironmentVariableW
161
 
//sys   SetFileTime(handle int32, ctime *Filetime, atime *Filetime, wtime *Filetime) (errno int)
 
167
//sys   SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (errno int)
162
168
//sys   GetFileAttributes(name *uint16) (attrs uint32, errno int) [failretval==INVALID_FILE_ATTRIBUTES] = kernel32.GetFileAttributesW
163
169
//sys   SetFileAttributes(name *uint16, attrs uint32) (errno int) = kernel32.SetFileAttributesW
164
170
//sys   GetCommandLine() (cmd *uint16) = kernel32.GetCommandLineW
165
171
//sys   CommandLineToArgv(cmd *uint16, argc *int32) (argv *[8192]*[8192]uint16, errno int) [failretval==nil] = shell32.CommandLineToArgvW
166
 
//sys   LocalFree(hmem uint32) (handle uint32, errno int) [failretval!=0]
167
 
//sys   SetHandleInformation(handle int32, mask uint32, flags uint32) (errno int)
168
 
//sys   FlushFileBuffers(handle int32) (errno int)
 
172
//sys   LocalFree(hmem Handle) (handle Handle, errno int) [failretval!=0]
 
173
//sys   SetHandleInformation(handle Handle, mask uint32, flags uint32) (errno int)
 
174
//sys   FlushFileBuffers(handle Handle) (errno int)
169
175
//sys   GetFullPathName(path *uint16, buflen uint32, buf *uint16, fname **uint16) (n uint32, errno int) = kernel32.GetFullPathNameW
170
 
//sys   CreateFileMapping(fhandle int32, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle int32, errno int) = kernel32.CreateFileMappingW
171
 
//sys   MapViewOfFile(handle int32, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, errno int)
 
176
//sys   CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, errno int) = kernel32.CreateFileMappingW
 
177
//sys   MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, errno int)
172
178
//sys   UnmapViewOfFile(addr uintptr) (errno int)
173
179
//sys   FlushViewOfFile(addr uintptr, length uintptr) (errno int)
174
180
//sys   VirtualLock(addr uintptr, length uintptr) (errno int)
175
181
//sys   VirtualUnlock(addr uintptr, length uintptr) (errno int)
 
182
//sys   TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (errno int) = wsock32.TransmitFile
176
183
 
177
184
// syscall interface implementation for other packages
178
185
 
204
211
        return &sa
205
212
}
206
213
 
207
 
func Open(path string, mode int, perm uint32) (fd int, errno int) {
 
214
func Open(path string, mode int, perm uint32) (fd Handle, errno int) {
208
215
        if len(path) == 0 {
209
 
                return -1, ERROR_FILE_NOT_FOUND
 
216
                return InvalidHandle, ERROR_FILE_NOT_FOUND
210
217
        }
211
218
        var access uint32
212
219
        switch mode & (O_RDONLY | O_WRONLY | O_RDWR) {
243
250
                createmode = OPEN_EXISTING
244
251
        }
245
252
        h, e := CreateFile(StringToUTF16Ptr(path), access, sharemode, sa, createmode, FILE_ATTRIBUTE_NORMAL, 0)
246
 
        return int(h), int(e)
 
253
        return h, int(e)
247
254
}
248
255
 
249
 
func Read(fd int, p []byte) (n int, errno int) {
 
256
func Read(fd Handle, p []byte) (n int, errno int) {
250
257
        var done uint32
251
 
        e := ReadFile(int32(fd), p, &done, nil)
 
258
        e := ReadFile(fd, p, &done, nil)
252
259
        if e != 0 {
253
260
                if e == ERROR_BROKEN_PIPE {
254
261
                        // NOTE(brainman): work around ERROR_BROKEN_PIPE is returned on reading EOF from stdin
259
266
        return int(done), 0
260
267
}
261
268
 
262
 
func Write(fd int, p []byte) (n int, errno int) {
 
269
func Write(fd Handle, p []byte) (n int, errno int) {
263
270
        var done uint32
264
 
        e := WriteFile(int32(fd), p, &done, nil)
 
271
        e := WriteFile(fd, p, &done, nil)
265
272
        if e != 0 {
266
273
                return 0, e
267
274
        }
268
275
        return int(done), 0
269
276
}
270
277
 
271
 
func Seek(fd int, offset int64, whence int) (newoffset int64, errno int) {
 
278
func Seek(fd Handle, offset int64, whence int) (newoffset int64, errno int) {
272
279
        var w uint32
273
280
        switch whence {
274
281
        case 0:
281
288
        hi := int32(offset >> 32)
282
289
        lo := int32(offset)
283
290
        // use GetFileType to check pipe, pipe can't do seek
284
 
        ft, _ := GetFileType(uint32(fd))
 
291
        ft, _ := GetFileType(fd)
285
292
        if ft == FILE_TYPE_PIPE {
286
293
                return 0, EPIPE
287
294
        }
288
 
        rlo, e := SetFilePointer(int32(fd), lo, &hi, w)
 
295
        rlo, e := SetFilePointer(fd, lo, &hi, w)
289
296
        if e != 0 {
290
297
                return 0, e
291
298
        }
292
299
        return int64(hi)<<32 + int64(rlo), 0
293
300
}
294
301
 
295
 
func Close(fd int) (errno int) {
296
 
        return CloseHandle(int32(fd))
 
302
func Close(fd Handle) (errno int) {
 
303
        return CloseHandle(fd)
297
304
}
298
305
 
299
306
var (
302
309
        Stderr = getStdHandle(STD_ERROR_HANDLE)
303
310
)
304
311
 
305
 
func getStdHandle(h int32) (fd int) {
 
312
func getStdHandle(h int) (fd Handle) {
306
313
        r, _ := GetStdHandle(h)
307
 
        return int(r)
 
314
        return r
308
315
}
309
316
 
310
317
func Stat(path string, stat *Stat_t) (errno int) {
383
390
        return string(utf16.Decode(b[0:n])), 0
384
391
}
385
392
 
386
 
func Ftruncate(fd int, length int64) (errno int) {
 
393
func Ftruncate(fd Handle, length int64) (errno int) {
387
394
        curoffset, e := Seek(fd, 0, 1)
388
395
        if e != 0 {
389
396
                return e
393
400
        if e != 0 {
394
401
                return e
395
402
        }
396
 
        e = SetEndOfFile(int32(fd))
 
403
        e = SetEndOfFile(fd)
397
404
        if e != 0 {
398
405
                return e
399
406
        }
412
419
        return 0
413
420
}
414
421
 
415
 
func Pipe(p []int) (errno int) {
 
422
func Pipe(p []Handle) (errno int) {
416
423
        if len(p) != 2 {
417
424
                return EINVAL
418
425
        }
419
 
        var r, w uint32
 
426
        var r, w Handle
420
427
        e := CreatePipe(&r, &w, makeInheritSa(), 0)
421
428
        if e != 0 {
422
429
                return e
423
430
        }
424
 
        p[0] = int(r)
425
 
        p[1] = int(w)
 
431
        p[0] = r
 
432
        p[1] = w
426
433
        return 0
427
434
}
428
435
 
436
443
        if e != 0 {
437
444
                return e
438
445
        }
439
 
        defer Close(int(h))
 
446
        defer Close(h)
440
447
        a := NsecToFiletime(tv[0].Nanoseconds())
441
448
        w := NsecToFiletime(tv[1].Nanoseconds())
442
449
        return SetFileTime(h, nil, &a, &w)
443
450
}
444
451
 
445
 
func Fsync(fd int) (errno int) {
446
 
        return FlushFileBuffers(int32(fd))
 
452
func Fsync(fd Handle) (errno int) {
 
453
        return FlushFileBuffers(fd)
447
454
}
448
455
 
449
456
func Chmod(path string, mode uint32) (errno int) {
467
474
 
468
475
//sys   WSAStartup(verreq uint32, data *WSAData) (sockerrno int) = wsock32.WSAStartup
469
476
//sys   WSACleanup() (errno int) [failretval==-1] = wsock32.WSACleanup
470
 
//sys   socket(af int32, typ int32, protocol int32) (handle int32, errno int) [failretval==-1] = wsock32.socket
471
 
//sys   setsockopt(s int32, level int32, optname int32, optval *byte, optlen int32) (errno int) [failretval==-1] = wsock32.setsockopt
472
 
//sys   bind(s int32, name uintptr, namelen int32) (errno int) [failretval==-1] = wsock32.bind
473
 
//sys   connect(s int32, name uintptr, namelen int32) (errno int) [failretval==-1] = wsock32.connect
474
 
//sys   getsockname(s int32, rsa *RawSockaddrAny, addrlen *int32) (errno int) [failretval==-1] = wsock32.getsockname
475
 
//sys   getpeername(s int32, rsa *RawSockaddrAny, addrlen *int32) (errno int) [failretval==-1] = wsock32.getpeername
476
 
//sys   listen(s int32, backlog int32) (errno int) [failretval==-1] = wsock32.listen
477
 
//sys   shutdown(s int32, how int32) (errno int) [failretval==-1] = wsock32.shutdown
478
 
//sys   Closesocket(s int32) (errno int) [failretval==-1] = wsock32.closesocket
479
 
//sys   AcceptEx(ls uint32, as uint32, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (errno int) = wsock32.AcceptEx
 
477
//sys   WSAIoctl(s Handle, iocc uint32, inbuf *byte, cbif uint32, outbuf *byte, cbob uint32, cbbr *uint32, overlapped *Overlapped, completionRoutine uintptr) (errno int) [failretval==-1] = ws2_32.WSAIoctl
 
478
//sys   socket(af int32, typ int32, protocol int32) (handle Handle, errno int) [failretval==InvalidHandle] = wsock32.socket
 
479
//sys   setsockopt(s Handle, level int32, optname int32, optval *byte, optlen int32) (errno int) [failretval==-1] = wsock32.setsockopt
 
480
//sys   bind(s Handle, name uintptr, namelen int32) (errno int) [failretval==-1] = wsock32.bind
 
481
//sys   connect(s Handle, name uintptr, namelen int32) (errno int) [failretval==-1] = wsock32.connect
 
482
//sys   getsockname(s Handle, rsa *RawSockaddrAny, addrlen *int32) (errno int) [failretval==-1] = wsock32.getsockname
 
483
//sys   getpeername(s Handle, rsa *RawSockaddrAny, addrlen *int32) (errno int) [failretval==-1] = wsock32.getpeername
 
484
//sys   listen(s Handle, backlog int32) (errno int) [failretval==-1] = wsock32.listen
 
485
//sys   shutdown(s Handle, how int32) (errno int) [failretval==-1] = wsock32.shutdown
 
486
//sys   Closesocket(s Handle) (errno int) [failretval==-1] = wsock32.closesocket
 
487
//sys   AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (errno int) = wsock32.AcceptEx
480
488
//sys   GetAcceptExSockaddrs(buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, lrsa **RawSockaddrAny, lrsalen *int32, rrsa **RawSockaddrAny, rrsalen *int32) = wsock32.GetAcceptExSockaddrs
481
 
//sys   WSARecv(s uint32, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, overlapped *Overlapped, croutine *byte) (errno int) [failretval==-1] = ws2_32.WSARecv
482
 
//sys   WSASend(s uint32, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (errno int) [failretval==-1] = ws2_32.WSASend
483
 
//sys   WSARecvFrom(s uint32, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32,  from *RawSockaddrAny, fromlen *int32, overlapped *Overlapped, croutine *byte) (errno int) [failretval==-1] = ws2_32.WSARecvFrom
484
 
//sys   WSASendTo(s uint32, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *RawSockaddrAny, tolen int32,  overlapped *Overlapped, croutine *byte) (errno int) [failretval==-1] = ws2_32.WSASendTo
 
489
//sys   WSARecv(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, overlapped *Overlapped, croutine *byte) (errno int) [failretval==-1] = ws2_32.WSARecv
 
490
//sys   WSASend(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (errno int) [failretval==-1] = ws2_32.WSASend
 
491
//sys   WSARecvFrom(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32,  from *RawSockaddrAny, fromlen *int32, overlapped *Overlapped, croutine *byte) (errno int) [failretval==-1] = ws2_32.WSARecvFrom
 
492
//sys   WSASendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *RawSockaddrAny, tolen int32,  overlapped *Overlapped, croutine *byte) (errno int) [failretval==-1] = ws2_32.WSASendTo
485
493
//sys   GetHostByName(name string) (h *Hostent, errno int) [failretval==nil] = ws2_32.gethostbyname
486
494
//sys   GetServByName(name string, proto string) (s *Servent, errno int) [failretval==nil] = ws2_32.getservbyname
487
495
//sys   Ntohs(netshort uint16) (u uint16) = ws2_32.ntohs
488
496
//sys   DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status uint32) = dnsapi.DnsQuery_W
489
497
//sys   DnsRecordListFree(rl *DNSRecord, freetype uint32) = dnsapi.DnsRecordListFree
 
498
//sys   GetIfEntry(pIfRow *MibIfRow) (errcode int) = iphlpapi.GetIfEntry
 
499
//sys   GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode int) = iphlpapi.GetAdaptersInfo
490
500
 
491
501
// For testing: clients can set this flag to force
492
502
// creation of IPv6 sockets to return EAFNOSUPPORT.
574
584
        return nil, EAFNOSUPPORT
575
585
}
576
586
 
577
 
func Socket(domain, typ, proto int) (fd, errno int) {
 
587
func Socket(domain, typ, proto int) (fd Handle, errno int) {
578
588
        if domain == AF_INET6 && SocketDisableIPv6 {
579
 
                return -1, EAFNOSUPPORT
 
589
                return InvalidHandle, EAFNOSUPPORT
580
590
        }
581
591
        h, e := socket(int32(domain), int32(typ), int32(proto))
582
 
        return int(h), int(e)
 
592
        return h, int(e)
583
593
}
584
594
 
585
 
func SetsockoptInt(fd, level, opt int, value int) (errno int) {
 
595
func SetsockoptInt(fd Handle, level, opt int, value int) (errno int) {
586
596
        v := int32(value)
587
 
        return int(setsockopt(int32(fd), int32(level), int32(opt), (*byte)(unsafe.Pointer(&v)), int32(unsafe.Sizeof(v))))
588
 
}
589
 
 
590
 
func Bind(fd int, sa Sockaddr) (errno int) {
591
 
        ptr, n, err := sa.sockaddr()
592
 
        if err != 0 {
593
 
                return err
594
 
        }
595
 
        return bind(int32(fd), ptr, n)
596
 
}
597
 
 
598
 
func Connect(fd int, sa Sockaddr) (errno int) {
599
 
        ptr, n, err := sa.sockaddr()
600
 
        if err != 0 {
601
 
                return err
602
 
        }
603
 
        return connect(int32(fd), ptr, n)
604
 
}
605
 
 
606
 
func Getsockname(fd int) (sa Sockaddr, errno int) {
607
 
        var rsa RawSockaddrAny
608
 
        l := int32(unsafe.Sizeof(rsa))
609
 
        if errno = getsockname(int32(fd), &rsa, &l); errno != 0 {
610
 
                return
611
 
        }
612
 
        return rsa.Sockaddr()
613
 
}
614
 
 
615
 
func Getpeername(fd int) (sa Sockaddr, errno int) {
616
 
        var rsa RawSockaddrAny
617
 
        l := int32(unsafe.Sizeof(rsa))
618
 
        if errno = getpeername(int32(fd), &rsa, &l); errno != 0 {
619
 
                return
620
 
        }
621
 
        return rsa.Sockaddr()
622
 
}
623
 
 
624
 
func Listen(s int, n int) (errno int) {
625
 
        return int(listen(int32(s), int32(n)))
626
 
}
627
 
 
628
 
func Shutdown(fd, how int) (errno int) {
629
 
        return int(shutdown(int32(fd), int32(how)))
630
 
}
631
 
 
632
 
func WSASendto(s uint32, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to Sockaddr, overlapped *Overlapped, croutine *byte) (errno int) {
 
597
        return int(setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&v)), int32(unsafe.Sizeof(v))))
 
598
}
 
599
 
 
600
func Bind(fd Handle, sa Sockaddr) (errno int) {
 
601
        ptr, n, err := sa.sockaddr()
 
602
        if err != 0 {
 
603
                return err
 
604
        }
 
605
        return bind(fd, ptr, n)
 
606
}
 
607
 
 
608
func Connect(fd Handle, sa Sockaddr) (errno int) {
 
609
        ptr, n, err := sa.sockaddr()
 
610
        if err != 0 {
 
611
                return err
 
612
        }
 
613
        return connect(fd, ptr, n)
 
614
}
 
615
 
 
616
func Getsockname(fd Handle) (sa Sockaddr, errno int) {
 
617
        var rsa RawSockaddrAny
 
618
        l := int32(unsafe.Sizeof(rsa))
 
619
        if errno = getsockname(fd, &rsa, &l); errno != 0 {
 
620
                return
 
621
        }
 
622
        return rsa.Sockaddr()
 
623
}
 
624
 
 
625
func Getpeername(fd Handle) (sa Sockaddr, errno int) {
 
626
        var rsa RawSockaddrAny
 
627
        l := int32(unsafe.Sizeof(rsa))
 
628
        if errno = getpeername(fd, &rsa, &l); errno != 0 {
 
629
                return
 
630
        }
 
631
        return rsa.Sockaddr()
 
632
}
 
633
 
 
634
func Listen(s Handle, n int) (errno int) {
 
635
        return int(listen(s, int32(n)))
 
636
}
 
637
 
 
638
func Shutdown(fd Handle, how int) (errno int) {
 
639
        return int(shutdown(fd, int32(how)))
 
640
}
 
641
 
 
642
func WSASendto(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to Sockaddr, overlapped *Overlapped, croutine *byte) (errno int) {
633
643
        rsa, l, err := to.sockaddr()
634
644
        if err != 0 {
635
645
                return err
666
676
 
667
677
// TODO(brainman): fix all needed for net
668
678
 
669
 
func Accept(fd int) (nfd int, sa Sockaddr, errno int)                        { return 0, nil, EWINDOWS }
670
 
func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, errno int) { return 0, nil, EWINDOWS }
671
 
func Sendto(fd int, p []byte, flags int, to Sockaddr) (errno int)            { return EWINDOWS }
672
 
func SetsockoptTimeval(fd, level, opt int, tv *Timeval) (errno int)          { return EWINDOWS }
 
679
func Accept(fd Handle) (nfd Handle, sa Sockaddr, errno int) { return 0, nil, EWINDOWS }
 
680
func Recvfrom(fd Handle, p []byte, flags int) (n int, from Sockaddr, errno int) {
 
681
        return 0, nil, EWINDOWS
 
682
}
 
683
func Sendto(fd Handle, p []byte, flags int, to Sockaddr) (errno int)       { return EWINDOWS }
 
684
func SetsockoptTimeval(fd Handle, level, opt int, tv *Timeval) (errno int) { return EWINDOWS }
673
685
 
674
686
type Linger struct {
675
687
        Onoff  int32
691
703
        Interface uint32
692
704
}
693
705
 
694
 
func SetsockoptLinger(fd, level, opt int, l *Linger) (errno int)        { return EWINDOWS }
695
 
func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) (errno int)     { return EWINDOWS }
696
 
func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) (errno int) { return EWINDOWS }
697
 
func BindToDevice(fd int, device string) (errno int)                    { return EWINDOWS }
 
706
func SetsockoptLinger(fd Handle, level, opt int, l *Linger) (errno int)        { return EWINDOWS }
 
707
func SetsockoptIPMreq(fd Handle, level, opt int, mreq *IPMreq) (errno int)     { return EWINDOWS }
 
708
func SetsockoptIPv6Mreq(fd Handle, level, opt int, mreq *IPv6Mreq) (errno int) { return EWINDOWS }
 
709
func BindToDevice(fd Handle, device string) (errno int)                        { return EWINDOWS }
698
710
 
699
711
// TODO(brainman): fix all needed for os
700
712
 
701
713
func Getpid() (pid int)   { return -1 }
702
714
func Getppid() (ppid int) { return -1 }
703
715
 
704
 
func Fchdir(fd int) (errno int)                           { return EWINDOWS }
 
716
func Fchdir(fd Handle) (errno int)                        { return EWINDOWS }
705
717
func Link(oldpath, newpath string) (errno int)            { return EWINDOWS }
706
718
func Symlink(path, link string) (errno int)               { return EWINDOWS }
707
719
func Readlink(path string, buf []byte) (n int, errno int) { return 0, EWINDOWS }
708
720
 
709
 
func Fchmod(fd int, mode uint32) (errno int)           { return EWINDOWS }
 
721
func Fchmod(fd Handle, mode uint32) (errno int)        { return EWINDOWS }
710
722
func Chown(path string, uid int, gid int) (errno int)  { return EWINDOWS }
711
723
func Lchown(path string, uid int, gid int) (errno int) { return EWINDOWS }
712
 
func Fchown(fd int, uid int, gid int) (errno int)      { return EWINDOWS }
 
724
func Fchown(fd Handle, uid int, gid int) (errno int)   { return EWINDOWS }
713
725
 
714
726
func Getuid() (uid int)                  { return -1 }
715
727
func Geteuid() (euid int)                { return -1 }
719
731
 
720
732
// TODO(brainman): fix all this meaningless code, it is here to compile exec.go
721
733
 
722
 
func read(fd int, buf *byte, nbuf int) (n int, errno int) {
 
734
func read(fd Handle, buf *byte, nbuf int) (n int, errno int) {
723
735
        return 0, EWINDOWS
724
736
}
725
737
 
726
 
func fcntl(fd, cmd, arg int) (val int, errno int) {
 
738
func fcntl(fd Handle, cmd, arg int) (val int, errno int) {
727
739
        return 0, EWINDOWS
728
740
}
729
741