100+ results results for 'MSG_PEEK repo:sbt/cpython' (160 ms)
88 >MSG_DONTROUTE</a><br /> <a target="mainFrame" href="bert_rpr.rpc-module.html#MSG_OOB"
89 >MSG_OOB</a><br /> <a target="mainFrame" href="bert_rpr.rpc-module.html#MSG_PEEK"
90 >MSG_PEEK</a><br /> <a target="mainFrame" href="bert_rpr.rpc-module.html#MSG_TRUNC"
AsyncFile.py git://pkgs.fedoraproject.org/eric | Python | 293 lines
178 # read a line at a time.
179 line = self.sock.recv(size, socket.MSG_PEEK)
180
kernel_netlink_shared.c git://pkgs.fedoraproject.org/strongswan | C | 307 lines
163 * numbers to detect multi header messages */
164 len = recvfrom(this->socket, &peek, sizeof(peek), MSG_PEEK | MSG_DONTWAIT,
165 (struct sockaddr*)&addr, &addr_len);
ospf6_network.c https://github.com/labx-technologies-llc/mb-linux-labx.git | C | 501 lines
458void
459ospf6_recvmsg_peek (struct in6_addr *src, struct in6_addr *dst,
460 unsigned int *ifindex, struct iovec *message)
486
487 retval = recvmsg (ospf6_sock, &rmsghdr, MSG_PEEK);
488 if (retval != iov_totallen (message))
sock.c https://github.com/hackndev/linux-hnd.git | C | 388 lines
112
113 result = _recvfrom(socket, header, 4, MSG_PEEK);
114 if (result == -EAGAIN)
TCP.cpp https://gitlab.com/piconf/software.git | C++ | 308 lines
104void VIO::TCP::read() {
105 int bytes = recv(fd, destinations.front().data, destinations.front().left, destinations.front().size ? 0 : MSG_PEEK);
106 if (0 > bytes)
ngx_http_ajp_msg.c https://github.com/yaoweibin/nginx_ajp_module.git | C | 482 lines
244ngx_int_t
245ajp_msg_peek_uint16(ajp_msg_t *msg, uint16_t *rvalue)
246{
252 if ((buf->pos + 2) > buf->last) {
253 return ajp_log_overflow(msg, "ajp_msg_peek_uint16");
254 }
265ngx_int_t
266ajp_msg_peek_uint8(ajp_msg_t *msg, u_char *rvalue)
267{
268 if ((msg->buf->pos + 1) > msg->buf->last) {
269 return ajp_log_overflow(msg, "ajp_msg_peek_uint8");
270 }
vsock_test.c git://github.com/torvalds/linux.git | C | 456 lines
252
253static void test_stream_msg_peek_client(const struct test_opts *opts)
254{
266
267static void test_stream_msg_peek_server(const struct test_opts *opts)
268{
276
277 recv_byte(fd, 1, MSG_PEEK);
278 recv_byte(fd, 1, 0);
307 {
308 .name = "SOCK_STREAM MSG_PEEK",
309 .run_client = test_stream_msg_peek_client,
309 .run_client = test_stream_msg_peek_client,
310 .run_server = test_stream_msg_peek_server,
311 },
os_socket.h git://github.com/insider42/mangos.git | C Header | 307 lines
154
155#if !defined (MSG_PEEK)
156# define MSG_PEEK 0x2
156# define MSG_PEEK 0x2
157#endif /* MSG_PEEK */
158
socket.c git://pkgs.fedoraproject.org/cntlm | C | 284 lines
210 fcntl(fd, F_SETFL, flags | O_NONBLOCK);
211 i = recv(fd, &buf, 1, MSG_PEEK);
212 fcntl(fd, F_SETFL, flags);
213#else
214 i = recv(fd, &buf, 1, MSG_DONTWAIT | MSG_PEEK);
215#endif
fh_tcp.c https://github.com/csinitiative/fhce.git | C | 623 lines
405
406 if (flags != MSG_PEEK) {
407 nleft -= nread;
504
505 if (flags != MSG_PEEK) {
506 nleft -= nread;
543{
544 return fh_tcp_readex(s, buf, nbytes, MSG_PEEK);
545}
LSOCK.cpp https://bitbucket.org/oregon/oregoncore/ | C++ | 184 lines
134 &recv_msg,
135 MSG_PEEK);
136
143#if defined (ACE_HAS_4_4BSD_SENDMSG_RECVMSG)
144 // Close down the socket that was returned by the MSG_PEEK.
145 cmsghdr *cmsgptr = (cmsghdr *) cmsgbuf;
socket.scm https://code.google.com/p/sagittarius-scheme/ | Scheme | 92 lines
62 MSG_OOB
63 MSG_PEEK
64 MSG_DONTROUTE
tcp.pl https://github.com/wtj/formosa.git | Perl | 476 lines
100 eval 'sub MSG_OOB {0x1;}';
101 eval 'sub MSG_PEEK {0x2;}';
102 eval 'sub MSG_DONTROUTE {0x4;}';
socket_base.hpp git://github.com/mongodb/mongo.git | C++ Header | 523 lines
69 BOOST_ASIO_STATIC_CONSTANT(int,
70 message_peek = BOOST_ASIO_OS_DEF(MSG_PEEK));
71 BOOST_ASIO_STATIC_CONSTANT(int,
socket_types.hpp https://code.google.com/p/dreamofgame/ | C++ Header | 217 lines
152const int shutdown_both = SD_BOTH;
153const int message_peek = MSG_PEEK;
154const int message_out_of_band = MSG_OOB;
195const int shutdown_both = SHUT_RDWR;
196const int message_peek = MSG_PEEK;
197const int message_out_of_band = MSG_OOB;
glibconfig-x86.h https://bitbucket.org/jnbek/pchat-dev | C Header | 227 lines
220#define GLIB_SYSDEF_MSG_OOB 1
221#define GLIB_SYSDEF_MSG_PEEK 2
222#define GLIB_SYSDEF_MSG_DONTROUTE 4
vchi.h https://github.com/tytso/ext4.git | C Header | 238 lines
132// will return the same message.
133extern int32_t vchi_msg_peek(VCHI_SERVICE_HANDLE_T handle,
134 void **data,
vchi.h git://github.com/torvalds/linux.git | C Header | 240 lines
133// will return the same message.
134extern int32_t vchi_msg_peek(struct vchi_service_handle *handle,
135 void **data,
socket.d git://github.com/SiegeLord/Tango-D2.git | D | 0 lines
95MSG_OOB
96MSG_PEEK
97MSG_TRUNC
slp_network.c https://openslp.svn.sourceforge.net/svnroot/openslp | C | 383 lines
288 16,
289 MSG_PEEK,
290 (struct sockaddr *)peeraddr,
test_sockmap.c git://github.com/torvalds/linux.git | C | 1853 lines
449{
450 struct msghdr msg = {0}, msg_peek = {0};
451 int err, i, flags = MSG_NOSIGNAL;
458 if (peek_flag) {
459 err = msg_alloc_iov(&msg_peek, iov_count, iov_length, data, tx);
460 if (err)
534 if (peek_flag) {
535 flags |= MSG_PEEK;
536 recvp = recvmsg(fd, &msg_peek, flags);
567 if (recvp) {
568 errno = msg_verify_data(&msg_peek,
569 recvp,
571 if (errno) {
572 perror("data verify msg_peek failed");
573 goto out_errno;
socket.rs git://github.com/djehuty/ibis.git | Rust | 658 lines
116 /*pub enum RecvOptions {
117 MSG_PEEK = 0x2,
118 MSG_DONTWAIT = 0x40,
vpServer.cpp https://github.com/thomas-moulard/visp-deb.git | C++ | 284 lines
256#ifdef UNIX
257 int numbytes = recv(receptor_list[i].socketFileDescriptorReceptor, &deco, 1, MSG_PEEK);
258#else //Win32
258#else //Win32
259 int numbytes = recv((unsigned int)receptor_list[i].socketFileDescriptorReceptor, &deco, 1, MSG_PEEK);
260#endif
IN.py https://github.com/labx-technologies-llc/mb-linux-labx.git | Python | 430 lines
145MSG_OOB = 1
146MSG_PEEK = 2
147MSG_DONTROUTE = 4
msg.c https://quake.svn.sourceforge.net/svnroot/quake | C | 382 lines
372int
373MSG_PeekByte (msg_t *msg)
374{
mod_jaxer_message.h https://github.com/aptana/Jaxer.git | C Header | 150 lines
105 */
106 int jxr_msg_peek_int16(unsigned char* buf, apr_size_t pos);
107
108 char jxr_msg_get_byte(unsigned char* buf, apr_size_t *pos);
109 char jxr_msg_peek_byte(unsigned char* buf, apr_size_t *pos);
110
win32-constants.lisp git://github.com/antifuchs/sbcl.git | Lisp | 234 lines
55 (:integer msg-oob "MSG_OOB")
56 (:integer msg-peek "MSG_PEEK")
57 (:integer msg-dontroute "MSG_DONTROUTE")
tcp_bpf.c https://github.com/tytso/ext4.git | C | 628 lines
16 struct iov_iter *iter = &msg->msg_iter;
17 int peek = flags & MSG_PEEK;
18 int i, ret, copied = 0;
Test.pm https://github.com/bestpractical/net-imap-server.git | Perl | 229 lines
90 # not under a layer version, anyways.
91 my $waiting = recv($socket, $buf, 1, MSG_PEEK | MSG_DONTWAIT);
92
sockets.h https://github.com/meriac/openbeacon.git | C Header | 346 lines
134/* Flags we can use with send and recv. */
135#define MSG_PEEK 0x01 /* Peeks at an incoming message */
136#define MSG_WAITALL 0x02 /* Unimplemented: Requests that the function block until the full amount of data requested can be returned */
netstring.c https://gitlab.com/javajamesb08/kamailio.git | C | 198 lines
44 /* Peek at first 10 bytes, to get length and colon */
45 bytes = recv(fd,buffer,10,MSG_PEEK);
46
ByteStringSpec.hs git://github.com/haskell/network.git | Haskell | 308 lines
226 (_, msgs, _, _flags) <- recvMsg sock 1024 0 MSG_PEEK
227 -- flags .&. MSG_PEEK `shouldBe` MSG_PEEK -- Mac only
228 (_, msgs', _, _) <- recvMsg sock 1024 0 mempty
rpclocal.c git://pkgs.fedoraproject.org/ocaml-ocamlnet | C | 256 lines
161
162 if (recvmsg(Int_val(fd), &msg, MSG_PEEK) < 0) {
163 uerror("recvmsg", Nothing);
219
220 if (recvmsg(Int_val(fd), &msg, MSG_PEEK) < 0) {
221 stat_free(crmsg);
ph.t http://perl5005.googlecode.com/svn/trunk/ | Perl | 97 lines
17 AF_SNA AF_UNIX AF_UNSPEC AF_X25 MSG_DONTROUTE MSG_MAXIOVLEN MSG_OOB
18 MSG_PEEK PF_802 PF_APPLETALK PF_CCITT PF_CHAOS PF_DATAKIT PF_DECnet PF_DLI
19 PF_ECMA PF_GOSIP PF_HYLINK PF_IMPLINK PF_INET PF_LAT PF_MAX PF_NBS PF_NIT
CUdpSocket.c git://pkgs.fedoraproject.org/gambas3 | C | 649 lines
97 block = GB.Stream.Block(&SOCKET->stream, TRUE);
98 USE_MSG_NOSIGNAL(ret = recvfrom(SOCKET->socket, (void*)buffer, sizeof(char), MSG_PEEK | MSG_NOSIGNAL, (struct sockaddr*)&THIS->addr, &host_len));
99 GB.Stream.Block(&SOCKET->stream, block);
141
142 //USE_MSG_NOSIGNAL(numpoll=recvfrom(t_sock,POINTER(buf), sizeof(char), MSG_PEEK | MSG_NOSIGNAL, (struct sockaddr*)&t_test, &t_test_len));
143 fill_buffer(THIS);
514
515 peeking = MSG_NOSIGNAL | MSG_PEEK;
516
sockex.c git://git.savannah.nongnu.org/liquidwar.git | C | 704 lines
162 */
163 if (recv (sock_copy, buffer, len, MSG_PEEK) == len)
164 {
OverbyteIcsWinsock.pas http://dm-rc-server.googlecode.com/svn/trunk/ | Pascal | 736 lines
154 {$EXTERNALSYM MSG_PEEK}
155 MSG_PEEK = Winsock.MSG_PEEK;
156 {$EXTERNALSYM MSG_OOB}
pisock.py git://pkgs.fedoraproject.org/pilot-link | Python | 990 lines
71PI_CMD_SYS = _pisock.PI_CMD_SYS
72PI_MSG_PEEK = _pisock.PI_MSG_PEEK
73PI_PF_DEV = _pisock.PI_PF_DEV
pi-socket.h git://pkgs.fedoraproject.org/pilot-link | C Header | 580 lines
75#define PI_CMD_SYS 0x03 /**< SYS protocol type (low-level, debugger connections) */
76#define PI_MSG_PEEK 0x01 /**< Use this flag with pi_recv() to 'peek' at the incoming data (will not be removed from input buffer) */
77/* deprecated (wasn't used)
players.c git://pkgs.fedoraproject.org/esound | C | 678 lines
232 if ( FD_ISSET(player->source_id, &rd_fds)
233 && (recv(player->source_id, &ch, 1, MSG_PEEK) < 1) ) {
234 /* Error or EOF */
socket.h git://pkgs.fedoraproject.org/glibmm24 | C Header | 1081 lines
130 SOCKET_MSG_OOB = GLIB_SYSDEF_MSG_OOB,
131 SOCKET_MSG_PEEK = GLIB_SYSDEF_MSG_PEEK,
132 SOCKET_MSG_DONTROUTE = GLIB_SYSDEF_MSG_DONTROUTE
natPlainDatagramSocketImpl.cc git://pkgs.fedoraproject.org/compat-gcc-32 | C++ | 704 lines
269 ssize_t retlen =
270 ::recvfrom (fnum, (char *) NULL, 0, MSG_PEEK, (sockaddr*) &u,
271 &addrlen);
EddyLinux__Sockets.cpp https://netmflinux.svn.codeplex.com/svn | C++ | 1045 lines
185 case SOCKET_READ_PEEK_OPTION:
186 nativeFlag = MSG_PEEK;
187 break;
UTSecureSocket.cpp https://FilerFrog.svn.codeplex.com/svn | C++ | 2421 lines
149 MoveMemory(buf, m_lpszDecodedData, dwBytesToCopy);
150 if((flags & MSG_PEEK) == FALSE)
151 {
nic_nl.c git://pkgs.fedoraproject.org/iscsi-initiator-utils | C | 499 lines
209 do {
210 rc = nlpayload_read(fd, (void*)ev, sizeof(*ev), MSG_PEEK);
211 if (rc < 0) {
275 if ((rc = nl_read(nl_sock, nlm_ev,
276 NLMSG_SPACE(sizeof(struct iscsi_uevent)), MSG_PEEK)) < 0) {
277 LOG_ERR("can not read nlm_ev, error %d", rc);
test_sockmap.c https://github.com/tytso/ext4.git | C | 2016 lines
554{
555 struct msghdr msg = {0}, msg_peek = {0};
556 int err, i, flags = MSG_NOSIGNAL;
563 if (peek_flag) {
564 err = msg_alloc_iov(&msg_peek, iov_count, iov_length, data, tx);
565 if (err)
645 if (peek_flag) {
646 flags |= MSG_PEEK;
647 recvp = recvmsg(fd, &msg_peek, flags);
php_http.c http://php52-backports.googlecode.com/svn/trunk/ | C | 1380 lines
49 if (php_pollfd_for_ms(socket, PHP_POLLREADABLE, 0) > 0) {
50 if (0 == recv(socket, &buf, sizeof(buf), MSG_PEEK) && php_socket_errno() != EAGAIN) {
51 return FALSE;
xp_socket.c http://php52-backports.googlecode.com/svn/trunk/ | C | 834 lines
37
38#ifndef MSG_PEEK
39# define MSG_PEEK 0
291 } else if (php_pollfd_for(sock->socket, PHP_POLLREADABLE|POLLPRI, &tv) > 0) {
292 if (0 >= recv(sock->socket, &buf, sizeof(buf), MSG_PEEK) && php_socket_errno() != EWOULDBLOCK) {
293 alive = 0;
367 if ((xparam->inputs.flags & STREAM_PEEK) == STREAM_PEEK) {
368 flags |= MSG_PEEK;
369 }
lasync.c http://luasync.googlecode.com/svn/trunk/ | C | 793 lines
643 for (i = 0; i < 1; i++) {
644 ret = sendmsg(fd, &msg.msg, i == 0 ? MSG_PEEK : 0);
645
constants.h http://android-ruby.googlecode.com/svn/trunk/ | C Header | 1080 lines
330#ifdef MSG_PEEK
331 sock_define_const("MSG_PEEK", MSG_PEEK);
332#endif
client.cpp https://github.com/drtrev/curses.git | C++ | 321 lines
239
240 numRecv = recv(sockfd, data, recvSize, MSG_PEEK);
241
natPlainDatagramSocketImplPosix.cc https://github.com/atgreen/moxiedev.git | C++ | 852 lines
198 ssize_t retlen =
199 ::recvfrom (native_fd, (char *) NULL, 0, MSG_PEEK, (sockaddr*) &u,
200 &addrlen);
261 retlen =
262 ::recvfrom (native_fd, (char *) dbytes, maxlen, MSG_PEEK, (sockaddr*) &u,
263 &addrlen);
MSocketSupport.bas http://xbot2003.googlecode.com/svn/trunk/ | Basic | 1175 lines
37Public Const MSG_OOB = &H1 '/* process out-of-band data */
38Public Const MSG_PEEK = &H2 '/* peek at incoming message */
39Public Const MSG_DONTROUTE = &H4 '/* send without using routing tables */
DtlsTransport.cxx http://openqwaq.googlecode.com/svn/trunk/ | C++ | 702 lines
127 // .dlb. can we determine the size of the buffer before we allocate?
128 // something about MSG_PEEK|MSG_TRUNC in Stevens..
129 // .dlb. RFC3261 18.1.1 MUST accept 65K datagrams. would have to attempt to
UdpTransport.cxx http://openqwaq.googlecode.com/svn/trunk/ | C++ | 549 lines
150 // .dlb. can we determine the size of the buffer before we allocate?
151 // something about MSG_PEEK|MSG_TRUNC in Stevens..
152 // .dlb. RFC3261 18.1.1 MUST accept 65K datagrams. would have to attempt to
poll.c git://git.savannah.gnu.org/gsasl.git | C | 608 lines
65
66/* BeOS does not have MSG_PEEK. */
67#ifndef MSG_PEEK
67#ifndef MSG_PEEK
68# define MSG_PEEK 0
69#endif
241 WSASetLastError (0);
242 r = recv (h, data, sizeof (data), MSG_PEEK);
243 error = WSAGetLastError ();
279# if defined __MACH__ && defined __APPLE__
280 /* There is a bug in Mac OS X that causes it to ignore MSG_PEEK
281 for some kinds of descriptors. Detect if this descriptor is a
283 0-byte recv, and use ioctl(2) to detect POLLHUP. */
284 r = recv (fd, NULL, 0, MSG_PEEK);
285 socket_errno = (r < 0) ? errno : 0;
socket_test.py git://github.com/IronLanguages/main.git | Python | 648 lines
136 "MSG_OOB" : 1,
137 "MSG_PEEK" : 2,
138 "MSG_TRUNC" : 32,
gnutls_buffers.c git://github.com/xbmc/xbmc.git | C | 1112 lines
297/* This function is only used with berkeley style sockets.
298 * Clears the peeked data (read with MSG_PEEK).
299 */
315
316 /* this was already read by using MSG_PEEK - so it shouldn't fail */
317 sum = 0;
346
347/* This function is like recv(with MSG_PEEK). But it does not return -1 on error.
348 * It does return MHD_gnutls_errno instead.
469 /* This is a hack placed in order for select to work. Just leave recvlowat data,
470 * into the kernel buffer (using a read with MSG_PEEK), thus making
471 * select think, that the socket is ready for reading.
471 * select think, that the socket is ready for reading.
472 * MSG_PEEK is only used with berkeley style sockets.
473 */
library.c git://github.com/nicolasff/phpredis.git | C | 2827 lines
193 * There is a bug in php socket stream to check liveness of a connection:
194 * if (0 >= recv(sock->socket, &buf, sizeof(buf), MSG_PEEK) && php_socket_errno() != EWOULDBLOCK) {
195 * alive = 0;
datagram.c https://bitbucket.org/sjohann81/linux-4.13.9.git | C | 862 lines
175
176 if (unlikely(flags & MSG_PEEK && *off >= 0)) {
177 peek_at_off = true;
182 skb_queue_walk(queue, skb) {
183 if (flags & MSG_PEEK) {
184 if (peek_at_off && _off >= skb->len &&
361
362 if (flags & MSG_PEEK) {
363 err = -ENOENT;
389 *
390 * If the MSG_PEEK flag is set, and the packet is still on the
391 * receive queue of the socket, it will be taken off the queue
lwt_unix_unix.c git://github.com/aryx/fork-ocsigen.git | C | 3737 lines
134static int msg_flag_table[] = {
135 MSG_OOB, MSG_DONTROUTE, MSG_PEEK
136};
sock.c git://pkgs.fedoraproject.org/idjc | C | 894 lines
216
217 l = recv (sock, &c, 1, MSG_PEEK);
218 if (l == 0)
libnetlink.c git://pkgs.fedoraproject.org/iproute | C | 692 lines
132 /* Check for immediate errors */
133 status = recv(rth->fd, resp, sizeof(resp), MSG_DONTWAIT|MSG_PEEK);
134 if (status < 0) {
GSHTTPURLHandle.m git://pkgs.fedoraproject.org/gnustep-base | Objective C | 1608 lines
64#ifdef HAVE_SYS_SOCKET_H
65# include <sys/socket.h> // For MSG_PEEK, etc
66#endif
netlink-types.h git://pkgs.fedoraproject.org/libnl3 | C Header | 848 lines
24#define NL_OWN_PORT (1<<2)
25#define NL_MSG_PEEK (1<<3)
26#define NL_NO_AUTO_ACK (1<<4)
socket_types.hpp https://github.com/mongodb/mongo.git | C++ Header | 419 lines
142# define BOOST_ASIO_OS_DEF_MSG_OOB 0x1
143# define BOOST_ASIO_OS_DEF_MSG_PEEK 0x2
144# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE 0x4
228# define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB
229# define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK
230# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
344# define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB
345# define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK
346# define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE
bigstring_unix_stubs.c https://github.com/janestreet/core.git | C | 753 lines
197 ssize_t n_read;
198 n_read = recv(sock, bstr, len, MSG_PEEK);
199 if (n_read == -1) uerror("bigstring_recv_peek_assume_fd_is_nonblocking", Nothing);
ipv4-header-test.cc https://bitbucket.org/cttc-lena/ns-3-lena-dev | C++ | 267 lines
104 availableData = socket->GetRxAvailable ();
105 m_receivedPacket = socket->Recv (2, MSG_PEEK);
106 NS_ASSERT (m_receivedPacket->GetSize () == 2);
extconf.rb git://github.com/ruby/ruby.git | Ruby | 681 lines
124
125RECVMSG_WITH_MSG_PEEK_ALLOCATE_FD_TEST = <<'EOF'
126#include <stdlib.h>
193
194 ss = recvmsg(sv[1], &r_msg, MSG_PEEK);
195 if (ss == -1) { perror("recvmsg"); exit(EXIT_FAILURE); }
245
246def test_recvmsg_with_msg_peek_creates_fds(headers)
247 case RUBY_PLATFORM
248 when /linux/
249 # Linux 2.6.38 allocate fds by recvmsg with MSG_PEEK.
250 close_fds = true
252 # FreeBSD 8.2.0, NetBSD 5 and MacOS X Snow Leopard doesn't
253 # allocate fds by recvmsg with MSG_PEEK.
254 # [ruby-dev:44189]
socket.d git://github.com/ldc-developers/druntime.git | D | 2353 lines
128MSG_OOB
129MSG_PEEK
130MSG_TRUNC
547 MSG_OOB = 0x01,
548 MSG_PEEK = 0x02,
549 MSG_TRUNC = 0x20,
socket.h https://bitbucket.org/cyanogenmod/android_bionic.git | C Header | 249 lines
194#define MSG_OOB 1
195#define MSG_PEEK 2
196#define MSG_DONTROUTE 4
system.c https://bitbucket.org/ghsb/sequoia-vm.git | C | 402 lines
18 char data;
19 if (recv(socket, &data, 1, MSG_PEEK | MSG_DONTWAIT) != 0)
20 return 1;
socket.d git://github.com/soywiz/pspemu.git | D | 670 lines
101MSG_OOB
102MSG_PEEK
103MSG_TRUNC
252 MSG_OOB = 0x01,
253 MSG_PEEK = 0x02,
254 MSG_TRUNC = 0x20,
402 MSG_OOB = 0x1,
403 MSG_PEEK = 0x2,
404 MSG_TRUNC = 0x10,
574 MSG_OOB = 0x1,
575 MSG_PEEK = 0x2,
576 MSG_TRUNC = 0x10,
SocketModule.java git://github.com/CleverCloud/Bianca.git | Java | 544 lines
68 private static final int MSG_WAITALL = 256;
69 private static final int MSG_PEEK = 2;
70 private static final int MSG_DONTROUTE = 4;
sockets.php git://pkgs.fedoraproject.org/php-bartlett-PHP-CompatInfo | PHP | 392 lines
219 'MSG_WAITALL' => array('4.1.0', ''),
220 'MSG_PEEK' => array('4.1.0', ''),
221 'MSG_DONTROUTE' => array('4.1.0', ''),
Makefile.PL https://code.google.com/p/android-scripting/ | Perl | 128 lines
48 LINK_MAX LONG_MAX LONG_MIN L_ctermid L_cuserid L_tmpnam MAX_CANON
49 MAX_INPUT MB_LEN_MAX MSG_CTRUNC MSG_DONTROUTE MSG_EOR MSG_OOB MSG_PEEK
50 MSG_TRUNC MSG_WAITALL NAME_MAX NCCS NGROUPS_MAX NOFLSH OPEN_MAX OPOST
socket.rb git://github.com/m2ym/rsense.git | Ruby | 461 lines
286 MSG_OOB = 0
287 MSG_PEEK = 0
288 MSG_RCVMORE = 0
socket.c git://github.com/torvalds/linux.git | C | 827 lines
147 if (len < copied) {
148 if (flags & MSG_PEEK)
149 refcount_dec(&skb->users);
Socket.cpp git://github.com/ungerik/BaseLib.git | C++ | 778 lines
487
488 const int bytesRead = recv(handle, static_cast<char*>(destination), destinationSize, MSG_PEEK);
489 if (bytesRead != SOCKET_ERROR)
590 int addrLen = sizeof(addr);
591 const int bytesRead = recvfrom(handle, static_cast<char *>(destination), destinationSize, MSG_PEEK, &addr, &addrLen);
592 if (bytesRead != SOCKET_ERROR)
recvmsg.c git://github.com/torvalds/linux.git | C | 772 lines
116
117 if (ret == 0 && !(flags & MSG_PEEK)) {
118 _debug("to be accepted");
352
353 if (!(flags & MSG_PEEK)) {
354 serial = sp->hdr.serial;
406 /* The whole packet has been transferred. */
407 if (!(flags & MSG_PEEK))
408 rxrpc_rotate_rx_window(call);
421out:
422 if (!(flags & MSG_PEEK)) {
423 call->rx_pkt_offset = rx_pkt_offset;
502 call = list_entry(l, struct rxrpc_call, recvmsg_link);
503 if (!(flags & MSG_PEEK))
504 list_del_init(&call->recvmsg_link);
vchiq_shim.c git://github.com/torvalds/linux.git | C | 751 lines
23/***********************************************************
24 * Name: vchi_msg_peek
25 *
38 ***********************************************************/
39int32_t vchi_msg_peek(struct vchi_service_handle *handle,
40 void **data,
60}
61EXPORT_SYMBOL(vchi_msg_peek);
62
68 * Description: Routine to remove a message (after it has been read with
69 * vchi_msg_peek)
70 *
_beos.h git://github.com/zpao/spidernode.git | C Header | 615 lines
96#define _PR_PEEK_BUFFER_MAX (16 * 1024)
97#define _PR_FD_NEED_EMULATE_MSG_PEEK(fd) 1
98#define _PR_CONNECT_DOES_NOT_BIND
RTIP__Sockets.cpp https://emichag.svn.codeplex.com/svn | C++ | 1174 lines
278 case SOCKET_READ_PEEK_OPTION:
279 nativeFlag = RTP_NET_MSG_PEEK;
280 break;
libref.ypsilon.socket.html http://ypsilon.googlecode.com/svn/trunk/ | HTML | 1695 lines
278 <td class="subject_td" nowrap>
279 <span class="subject_identifier"><a href="#MSG_PEEK">MSG_PEEK</a></span>
280 </td>
Berkeley.d git://github.com/SiegeLord/Tango-D2.git | D | 2412 lines
130 OOB = consts.MSG_OOB, /// out of band
131 PEEK = consts.MSG_PEEK, /// only for receiving
132 DONTROUTE = consts.MSG_DONTROUTE, /// only for sending
libpfk.cpp git://pkgs.fedoraproject.org/ike | C++ | 1814 lines
95
96 long result = recv( conn, msg.buff(), msg_size, MSG_PEEK );
97 if( result < 0 )
dtptserver.py git://pkgs.fedoraproject.org/synce-sync-engine | Python | 846 lines
165
166 buf = self.s.recv(2, socket.MSG_PEEK | socket.MSG_WAITALL)
167 if len(buf) > 0:
poll.c git://pkgs.fedoraproject.org/libssh | C | 639 lines
203 /* support for POLLHUP */
204 ret = recv(fds[i].fd, data, 64, MSG_PEEK);
205#ifdef _WIN32
ajp.h git://pkgs.fedoraproject.org/httpd | C++ Header | 520 lines
283 */
284apr_status_t ajp_msg_peek_uint16(ajp_msg_t *msg, apr_uint16_t *rvalue);
285
302 */
303apr_status_t ajp_msg_peek_uint8(ajp_msg_t *msg, apr_byte_t *rvalue);
304
io.c git://pkgs.fedoraproject.org/ratbox-services | C | 1501 lines
120 if((n = recv(conn_p->fd, conn_p->recvbuf + conn_p->recvbuf_offset,
121 sizeof(conn_p->recvbuf) - conn_p->recvbuf_offset, MSG_PEEK)) <= 0)
122 {
socket.c git://pkgs.fedoraproject.org/fetchmail | C | 1048 lines
66#define fm_write(a,b,c) write(a,b,c)
67#define fm_peek(a,b,c) recv(a,b,c, MSG_PEEK)
68#ifdef __CYGWIN__
435 /* Hack alert! */
436 /* OK... SSL_peek works a little different from MSG_PEEK
437 Problem is that SSL_peek can return 0 if there
RubySocket.java git://github.com/jruby/jruby.git | Java | 672 lines
109 rb_mConstants.setConstant("MSG_OOB", runtime.newFixnum(MSG_OOB));
110 rb_mConstants.setConstant("MSG_PEEK", runtime.newFixnum(MSG_PEEK));
111 rb_mConstants.setConstant("MSG_DONTROUTE", runtime.newFixnum(MSG_DONTROUTE));
platform.conf git://github.com/jruby/jruby.git | Config | 521 lines
240rbx.platform.socket.MSG_OOB = 1
241rbx.platform.socket.MSG_PEEK = 2
242rbx.platform.socket.MSG_RCVMORE =
sock_symbian.cpp http://csipsimple.googlecode.com/svn/trunk/ | C++ | 1022 lines
83const int PJ_MSG_OOB = 0;
84const int PJ_MSG_PEEK = KSockReadPeek;
85const int PJ_MSG_DONTROUTE = 0;
sock_bsd.c http://csipsimple.googlecode.com/svn/trunk/ | C | 844 lines
166const int PJ_MSG_OOB = MSG_OOB;
167const int PJ_MSG_PEEK = MSG_PEEK;
168const int PJ_MSG_DONTROUTE = MSG_DONTROUTE;
socket.c http://opensource.apple.com/release/ios-511/ | C | 1063 lines
74#<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_write</span>(a,b,c) write(a,b,c)
75#<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_peek</span>(a,b,c) recv(a,b,c, MSG_PEEK)
76#<span class="enscript-reference">ifdef</span> <span class="enscript-variable-name">__CYGWIN__</span>
socket.c http://opensource.apple.com/release/ios-511/ | C | 986 lines
74#<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_write</span>(a,b,c) write(a,b,c)
75#<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_peek</span>(a,b,c) recv(a,b,c, MSG_PEEK)
76#<span class="enscript-reference">define</span> <span class="enscript-function-name">fm_read</span>(a,b,c) read(a,b,c)
socket.c git://github.com/CyanogenMod/cm-kernel.git | C | 818 lines
159 if (len < copied) {
160 if (flags & MSG_PEEK)
161 atomic_dec(&skb->users);
datagram.c git://github.com/CyanogenMod/cm-kernel.git | C | 650 lines
173 *peeked = skb->peeked;
174 if (flags & MSG_PEEK) {
175 skb->peeked = 1;
224 *
225 * If the MSG_PEEK flag is set, and the packet is still on the
226 * receive queue of the socket, it will be taken off the queue
239
240 if (flags & MSG_PEEK) {
241 err = -ENOENT;
svcsock.c git://github.com/CyanogenMod/cm-kernel.git | C | 1319 lines
453 err = kernel_recvmsg(svsk->sk_sock, &msg, NULL,
454 0, 0, MSG_PEEK | MSG_DONTWAIT);
455 if (err >= 0)
recvfrom_spec.rb https://github.com/ruby/ruby.git | Ruby | 98 lines
34 it "uses different message options" do
35 @client.send("foobar", Socket::MSG_PEEK)
36 sock = @server.accept
36 sock = @server.accept
37 peek_data = sock.recvfrom(6, Socket::MSG_PEEK) # Does not retrieve the message
38 real_data = sock.recvfrom(6)
admin.c git://pkgs.fedoraproject.org/ipsec-tools | C | 764 lines
120 /* get buffer length */
121 while ((len = recv(so2, (char *)&com, sizeof(com), MSG_PEEK)) < 0) {
122 if (errno == EINTR)
ref.sockets.html git://pkgs.fedoraproject.org/kdewebdev | HTML | 1293 lines
391><B
392>MSG_PEEK</B
393></TT
SSL_SOCK_Stream.cpp https://bitbucket.org/CatrinaEmu/core/ | C++ | 631 lines
394 {
395 if ((flags | MSG_PEEK) != MSG_PEEK)
396 {
443 {
444 if ((flags | MSG_PEEK) != MSG_PEEK)
445 {
_winnt.h https://hg01.codeplex.com/kmbrasil | C Header | 0 lines
112#define _PR_PEEK_BUFFER_MAX (32 * 1024)
113#define _PR_FD_NEED_EMULATE_MSG_PEEK(fd) \
114 (!(fd)->secret->nonblocking && (fd)->secret->inheritable != _PR_TRI_TRUE)
_macos.h https://hg01.codeplex.com/kmbrasil | C Header | 0 lines
74#define _PR_PEEK_BUFFER_MAX (16 * 1024)
75#define _PR_FD_NEED_EMULATE_MSG_PEEK(fd) 1
76
constdefs.h git://github.com/rhomobile/rhodes.git | C Header | 1788 lines
431#endif
432#if !defined(MSG_PEEK)
433# if defined(HAVE_CONST_MSG_PEEK)
433# if defined(HAVE_CONST_MSG_PEEK)
434# define MSG_PEEK MSG_PEEK
435# endif