← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/pjlib/src/pj/sock_symbian.cpp

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/pjlib/src/pj/sock_symbian.cpp
1
 
/* $Id: sock_symbian.cpp 3553 2011-05-05 06:14:19Z nanang $ */
2
 
/*
3
 
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
4
 
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
5
 
 *
6
 
 * This program is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
9
 
 * (at your option) any later version.
10
 
 *
11
 
 * This program is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU General Public License
17
 
 * along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 
 */
20
 
#include <pj/sock.h>
21
 
#include <pj/addr_resolv.h>
22
 
#include <pj/assert.h>
23
 
#include <pj/errno.h>
24
 
#include <pj/os.h>
25
 
#include <pj/string.h>
26
 
#include <pj/unicode.h>
27
 
 
28
 
#include "os_symbian.h"
29
 
 
30
 
 
31
 
/*
32
 
 * Address families.
33
 
 */
34
 
const pj_uint16_t PJ_AF_UNSPEC  = KAFUnspec;
35
 
const pj_uint16_t PJ_AF_UNIX    = 0xFFFF;
36
 
const pj_uint16_t PJ_AF_INET    = KAfInet;
37
 
const pj_uint16_t PJ_AF_INET6   = KAfInet6;
38
 
const pj_uint16_t PJ_AF_PACKET  = 0xFFFF;
39
 
const pj_uint16_t PJ_AF_IRDA    = 0xFFFF;
40
 
 
41
 
/*
42
 
 * Socket types conversion.
43
 
 * The values here are indexed based on pj_sock_type
44
 
 */
45
 
const pj_uint16_t PJ_SOCK_STREAM= KSockStream;
46
 
const pj_uint16_t PJ_SOCK_DGRAM = KSockDatagram;
47
 
const pj_uint16_t PJ_SOCK_RAW   = 0xFFFF;
48
 
const pj_uint16_t PJ_SOCK_RDM   = 0xFFFF;
49
 
 
50
 
/* we don't support setsockopt(), these are just dummy values */
51
 
const pj_uint16_t PJ_SOL_SOCKET = 0xFFFF;
52
 
const pj_uint16_t PJ_SOL_IP     = 0xFFFF;
53
 
const pj_uint16_t PJ_SOL_TCP    = 0xFFFF;
54
 
const pj_uint16_t PJ_SOL_UDP    = 0xFFFF;
55
 
const pj_uint16_t PJ_SOL_IPV6   = 0xFFFF;
56
 
const pj_uint16_t PJ_SO_NOSIGPIPE = 0xFFFF;
57
 
 
58
 
/* TOS */
59
 
const pj_uint16_t PJ_IP_TOS             = 0;
60
 
const pj_uint16_t PJ_IPTOS_LOWDELAY     = 0;
61
 
const pj_uint16_t PJ_IPTOS_THROUGHPUT   = 0;
62
 
const pj_uint16_t PJ_IPTOS_RELIABILITY  = 0;
63
 
const pj_uint16_t PJ_IPTOS_MINCOST      = 0;
64
 
 
65
 
/* Misc */
66
 
const pj_uint16_t PJ_TCP_NODELAY = 0xFFFF;
67
 
const pj_uint16_t PJ_SO_REUSEADDR = 0xFFFF;
68
 
const pj_uint16_t PJ_SO_PRIORITY = 0xFFFF;
69
 
 
70
 
/* ioctl() is also not supported. */
71
 
const pj_uint16_t PJ_SO_TYPE    = 0xFFFF;
72
 
const pj_uint16_t PJ_SO_RCVBUF  = 0xFFFF;
73
 
const pj_uint16_t PJ_SO_SNDBUF  = 0xFFFF;
74
 
 
75
 
/* IP multicast is also not supported. */
76
 
const pj_uint16_t PJ_IP_MULTICAST_IF    = 0xFFFF;
77
 
const pj_uint16_t PJ_IP_MULTICAST_TTL   = 0xFFFF;
78
 
const pj_uint16_t PJ_IP_MULTICAST_LOOP  = 0xFFFF;
79
 
const pj_uint16_t PJ_IP_ADD_MEMBERSHIP  = 0xFFFF;
80
 
const pj_uint16_t PJ_IP_DROP_MEMBERSHIP = 0xFFFF;
81
 
 
82
 
/* Flags */
83
 
const int PJ_MSG_OOB         = 0;
84
 
const int PJ_MSG_PEEK        = KSockReadPeek;
85
 
const int PJ_MSG_DONTROUTE   = 0;
86
 
 
87
 
/////////////////////////////////////////////////////////////////////////////
88
 
//
89
 
// CPjSocket implementation.
90
 
// (declaration is in os_symbian.h)
91
 
//
92
 
 
93
 
CPjSocket::~CPjSocket()
94
 
{
95
 
    DestroyReader();
96
 
    sock_.Close();
97
 
}
98
 
 
99
 
 
100
 
// Create socket reader.
101
 
CPjSocketReader *CPjSocket::CreateReader(unsigned max_len)
102
 
{
103
 
    pj_assert(sockReader_ == NULL);
104
 
    return sockReader_ = CPjSocketReader::NewL(*this, max_len);
105
 
}
106
 
 
107
 
// Delete socket reader when it's not wanted.
108
 
void CPjSocket::DestroyReader()
109
 
{
110
 
    if (sockReader_) {
111
 
        sockReader_->Cancel();
112
 
        delete sockReader_;
113
 
        sockReader_ = NULL;
114
 
    }
115
 
}
116
 
 
117
 
 
118
 
/////////////////////////////////////////////////////////////////////////////
119
 
//
120
 
// CPjSocketReader implementation
121
 
// (declaration in os_symbian.h)
122
 
//
123
 
 
124
 
 
125
 
CPjSocketReader::CPjSocketReader(CPjSocket &sock)
126
 
: CActive(EPriorityStandard),
127
 
  sock_(sock), buffer_(NULL, 0), readCb_(NULL), key_(NULL)
128
 
{
129
 
}
130
 
 
131
 
 
132
 
void CPjSocketReader::ConstructL(unsigned max_len)
133
 
{
134
 
    isDatagram_ = sock_.IsDatagram();
135
 
 
136
 
    TUint8 *ptr = new TUint8[max_len];
137
 
    buffer_.Set(ptr, 0, (TInt)max_len);
138
 
    CActiveScheduler::Add(this);
139
 
}
140
 
 
141
 
CPjSocketReader *CPjSocketReader::NewL(CPjSocket &sock, unsigned max_len)
142
 
{
143
 
    CPjSocketReader *self = new (ELeave) CPjSocketReader(sock);
144
 
    CleanupStack::PushL(self);
145
 
    self->ConstructL(max_len);
146
 
    CleanupStack::Pop(self);
147
 
 
148
 
    return self;
149
 
}
150
 
 
151
 
 
152
 
CPjSocketReader::~CPjSocketReader()
153
 
{
154
 
    const TUint8 *data = buffer_.Ptr();
155
 
    delete [] data;
156
 
}
157
 
 
158
 
void CPjSocketReader::StartRecv(void (*cb)(void *key),
159
 
                                void *key,
160
 
                                TDes8 *aDesc,
161
 
                                TUint flags)
162
 
{
163
 
    StartRecvFrom(cb, key, aDesc, flags, NULL);
164
 
}
165
 
 
166
 
void CPjSocketReader::StartRecvFrom(void (*cb)(void *key),
167
 
                                    void *key,
168
 
                                    TDes8 *aDesc,
169
 
                                    TUint flags,
170
 
                                    TSockAddr *fromAddr)
171
 
{
172
 
    readCb_ = cb;
173
 
    key_ = key;
174
 
 
175
 
    if (aDesc == NULL) aDesc = &buffer_;
176
 
    if (fromAddr == NULL) fromAddr = &recvAddr_;
177
 
 
178
 
    sock_.Socket().RecvFrom(*aDesc, *fromAddr, flags, iStatus);
179
 
    SetActive();
180
 
}
181
 
 
182
 
void CPjSocketReader::DoCancel()
183
 
{
184
 
    sock_.Socket().CancelRecv();
185
 
}
186
 
 
187
 
void CPjSocketReader::RunL()
188
 
{
189
 
    void (*old_cb)(void *key) = readCb_;
190
 
    void *old_key = key_;
191
 
 
192
 
    readCb_ = NULL;
193
 
    key_ = NULL;
194
 
 
195
 
    if (old_cb) {
196
 
        (*old_cb)(old_key);
197
 
    }
198
 
}
199
 
 
200
 
// Append data to aDesc, up to aDesc's maximum size.
201
 
// If socket is datagram based, buffer_ will be clared.
202
 
void CPjSocketReader::ReadData(TDes8 &aDesc, TInetAddr *addr)
203
 
{
204
 
    if (isDatagram_)
205
 
        aDesc.Zero();
206
 
 
207
 
    if (buffer_.Length() == 0)
208
 
        return;
209
 
 
210
 
    TInt size_to_copy = aDesc.MaxLength() - aDesc.Length();
211
 
    if (size_to_copy > buffer_.Length())
212
 
        size_to_copy = buffer_.Length();
213
 
 
214
 
    aDesc.Append(buffer_.Ptr(), size_to_copy);
215
 
 
216
 
    if (isDatagram_)
217
 
        buffer_.Zero();
218
 
    else
219
 
        buffer_.Delete(0, size_to_copy);
220
 
 
221
 
    if (addr)
222
 
        *addr = recvAddr_;
223
 
}
224
 
 
225
 
 
226
 
 
227
 
/////////////////////////////////////////////////////////////////////////////
228
 
//
229
 
// PJLIB's sock.h implementation
230
 
//
231
 
 
232
 
/*
233
 
 * Convert 16-bit value from network byte order to host byte order.
234
 
 */
235
 
PJ_DEF(pj_uint16_t) pj_ntohs(pj_uint16_t netshort)
236
 
{
237
 
#if PJ_IS_LITTLE_ENDIAN
238
 
    return pj_swap16(netshort);
239
 
#else
240
 
    return netshort;
241
 
#endif
242
 
}
243
 
 
244
 
/*
245
 
 * Convert 16-bit value from host byte order to network byte order.
246
 
 */
247
 
PJ_DEF(pj_uint16_t) pj_htons(pj_uint16_t hostshort)
248
 
{
249
 
#if PJ_IS_LITTLE_ENDIAN
250
 
    return pj_swap16(hostshort);
251
 
#else
252
 
    return hostshort;
253
 
#endif
254
 
}
255
 
 
256
 
/*
257
 
 * Convert 32-bit value from network byte order to host byte order.
258
 
 */
259
 
PJ_DEF(pj_uint32_t) pj_ntohl(pj_uint32_t netlong)
260
 
{
261
 
#if PJ_IS_LITTLE_ENDIAN
262
 
    return pj_swap32(netlong);
263
 
#else
264
 
    return netlong;
265
 
#endif
266
 
}
267
 
 
268
 
/*
269
 
 * Convert 32-bit value from host byte order to network byte order.
270
 
 */
271
 
PJ_DEF(pj_uint32_t) pj_htonl(pj_uint32_t hostlong)
272
 
{
273
 
#if PJ_IS_LITTLE_ENDIAN
274
 
    return pj_swap32(hostlong);
275
 
#else
276
 
    return netlong;
277
 
#endif
278
 
}
279
 
 
280
 
/*
281
 
 * Convert an Internet host address given in network byte order
282
 
 * to string in standard numbers and dots notation.
283
 
 */
284
 
PJ_DEF(char*) pj_inet_ntoa(pj_in_addr inaddr)
285
 
{
286
 
        static char str8[PJ_INET_ADDRSTRLEN];
287
 
    TBuf<PJ_INET_ADDRSTRLEN> str16(0);
288
 
 
289
 
    /* (Symbian IP address is in host byte order) */
290
 
    TInetAddr temp_addr((TUint32)pj_ntohl(inaddr.s_addr), (TUint)0);
291
 
    temp_addr.Output(str16);
292
 
 
293
 
    return pj_unicode_to_ansi((const wchar_t*)str16.PtrZ(), str16.Length(),
294
 
                              str8, sizeof(str8));
295
 
}
296
 
 
297
 
/*
298
 
 * This function converts the Internet host address cp from the standard
299
 
 * numbers-and-dots notation into binary data and stores it in the structure
300
 
 * that inp points to.
301
 
 */
302
 
PJ_DEF(int) pj_inet_aton(const pj_str_t *cp, struct pj_in_addr *inp)
303
 
{
304
 
    enum { MAXIPLEN = PJ_INET_ADDRSTRLEN };
305
 
 
306
 
    /* Initialize output with PJ_INADDR_NONE.
307
 
     * Some apps relies on this instead of the return value
308
 
     * (and anyway the return value is quite confusing!)
309
 
     */
310
 
    inp->s_addr = PJ_INADDR_NONE;
311
 
 
312
 
    /* Caution:
313
 
     *  this function might be called with cp->slen >= 16
314
 
     *  (i.e. when called with hostname to check if it's an IP addr).
315
 
     */
316
 
    PJ_ASSERT_RETURN(cp && cp->slen && inp, 0);
317
 
    if (cp->slen >= 16) {
318
 
        return 0;
319
 
    }
320
 
 
321
 
    char tempaddr8[MAXIPLEN];
322
 
    pj_memcpy(tempaddr8, cp->ptr, cp->slen);
323
 
    tempaddr8[cp->slen] = '\0';
324
 
 
325
 
    wchar_t tempaddr16[MAXIPLEN];
326
 
    pj_ansi_to_unicode(tempaddr8, pj_ansi_strlen(tempaddr8),
327
 
                       tempaddr16, sizeof(tempaddr16));
328
 
 
329
 
    TBuf<MAXIPLEN> ip_addr((const TText*)tempaddr16);
330
 
 
331
 
    TInetAddr addr;
332
 
    addr.Init(KAfInet);
333
 
    if (addr.Input(ip_addr) == KErrNone) {
334
 
        /* Success (Symbian IP address is in host byte order) */
335
 
        inp->s_addr = pj_htonl(addr.Address());
336
 
        return 1;
337
 
    } else {
338
 
        /* Error */
339
 
        return 0;
340
 
    }
341
 
}
342
 
 
343
 
/*
344
 
 * Convert text to IPv4/IPv6 address.
345
 
 */
346
 
PJ_DEF(pj_status_t) pj_inet_pton(int af, const pj_str_t *src, void *dst)
347
 
{
348
 
    char tempaddr[PJ_INET6_ADDRSTRLEN];
349
 
 
350
 
    PJ_ASSERT_RETURN(af==PJ_AF_INET || af==PJ_AF_INET6, PJ_EINVAL);
351
 
    PJ_ASSERT_RETURN(src && src->slen && dst, PJ_EINVAL);
352
 
 
353
 
    /* Initialize output with PJ_IN_ADDR_NONE for IPv4 (to be
354
 
     * compatible with pj_inet_aton()
355
 
     */
356
 
    if (af==PJ_AF_INET) {
357
 
        ((pj_in_addr*)dst)->s_addr = PJ_INADDR_NONE;
358
 
    }
359
 
 
360
 
    /* Caution:
361
 
     *  this function might be called with cp->slen >= 46
362
 
     *  (i.e. when called with hostname to check if it's an IP addr).
363
 
     */
364
 
    if (src->slen >= PJ_INET6_ADDRSTRLEN) {
365
 
        return PJ_ENAMETOOLONG;
366
 
    }
367
 
 
368
 
    pj_memcpy(tempaddr, src->ptr, src->slen);
369
 
    tempaddr[src->slen] = '\0';
370
 
 
371
 
 
372
 
    wchar_t tempaddr16[PJ_INET6_ADDRSTRLEN];
373
 
    pj_ansi_to_unicode(tempaddr, pj_ansi_strlen(tempaddr),
374
 
                       tempaddr16, sizeof(tempaddr16));
375
 
 
376
 
    TBuf<PJ_INET6_ADDRSTRLEN> ip_addr((const TText*)tempaddr16);
377
 
 
378
 
    TInetAddr addr;
379
 
    addr.Init(KAfInet6);
380
 
    if (addr.Input(ip_addr) == KErrNone) {
381
 
        if (af==PJ_AF_INET) {
382
 
            /* Success (Symbian IP address is in host byte order) */
383
 
            pj_uint32_t ip = pj_htonl(addr.Address());
384
 
            pj_memcpy(dst, &ip, 4);
385
 
        } else if (af==PJ_AF_INET6) {
386
 
            const TIp6Addr & ip6 = addr.Ip6Address();
387
 
            pj_memcpy(dst, ip6.u.iAddr8, 16);
388
 
        } else {
389
 
            pj_assert(!"Unexpected!");
390
 
            return PJ_EBUG;
391
 
        }
392
 
        return PJ_SUCCESS;
393
 
    } else {
394
 
        /* Error */
395
 
        return PJ_EINVAL;
396
 
    }
397
 
}
398
 
 
399
 
/*
400
 
 * Convert IPv4/IPv6 address to text.
401
 
 */
402
 
PJ_DEF(pj_status_t) pj_inet_ntop(int af, const void *src,
403
 
                                 char *dst, int size)
404
 
 
405
 
{
406
 
    PJ_ASSERT_RETURN(src && dst && size, PJ_EINVAL);
407
 
 
408
 
    *dst = '\0';
409
 
 
410
 
    if (af==PJ_AF_INET) {
411
 
 
412
 
        TBuf<PJ_INET_ADDRSTRLEN> str16;
413
 
        pj_in_addr inaddr;
414
 
 
415
 
        if (size < PJ_INET_ADDRSTRLEN)
416
 
            return PJ_ETOOSMALL;
417
 
 
418
 
        pj_memcpy(&inaddr, src, 4);
419
 
 
420
 
        /* Symbian IP address is in host byte order */
421
 
        TInetAddr temp_addr((TUint32)pj_ntohl(inaddr.s_addr), (TUint)0);
422
 
        temp_addr.Output(str16);
423
 
 
424
 
        pj_unicode_to_ansi((const wchar_t*)str16.PtrZ(), str16.Length(),
425
 
                           dst, size);
426
 
        return PJ_SUCCESS;
427
 
 
428
 
    } else if (af==PJ_AF_INET6) {
429
 
        TBuf<PJ_INET6_ADDRSTRLEN> str16;
430
 
 
431
 
        if (size < PJ_INET6_ADDRSTRLEN)
432
 
            return PJ_ETOOSMALL;
433
 
 
434
 
        TIp6Addr ip6;
435
 
        pj_memcpy(ip6.u.iAddr8, src, 16);
436
 
 
437
 
        TInetAddr temp_addr(ip6, (TUint)0);
438
 
        temp_addr.Output(str16);
439
 
 
440
 
        pj_unicode_to_ansi((const wchar_t*)str16.PtrZ(), str16.Length(),
441
 
                           dst, size);
442
 
        return PJ_SUCCESS;
443
 
 
444
 
    } else {
445
 
        pj_assert(!"Unsupport address family");
446
 
        return PJ_EINVAL;
447
 
    }
448
 
 
449
 
}
450
 
 
451
 
/*
452
 
 * Get hostname.
453
 
 */
454
 
PJ_DEF(const pj_str_t*) pj_gethostname(void)
455
 
{
456
 
    static char buf[PJ_MAX_HOSTNAME];
457
 
    static pj_str_t hostname;
458
 
 
459
 
    PJ_CHECK_STACK();
460
 
 
461
 
    if (hostname.ptr == NULL) {
462
 
        RHostResolver &resv = PjSymbianOS::Instance()->GetResolver(PJ_AF_INET);
463
 
        TRequestStatus reqStatus;
464
 
        THostName tmpName;
465
 
 
466
 
        // Return empty hostname if access point is marked as down by app.
467
 
        PJ_SYMBIAN_CHECK_CONNECTION2(&hostname);
468
 
 
469
 
        resv.GetHostName(tmpName, reqStatus);
470
 
        User::WaitForRequest(reqStatus);
471
 
 
472
 
        hostname.ptr = pj_unicode_to_ansi((const wchar_t*)tmpName.Ptr(), tmpName.Length(),
473
 
                                          buf, sizeof(buf));
474
 
        hostname.slen = tmpName.Length();
475
 
    }
476
 
    return &hostname;
477
 
}
478
 
 
479
 
/*
480
 
 * Create new socket/endpoint for communication and returns a descriptor.
481
 
 */
482
 
PJ_DEF(pj_status_t) pj_sock_socket(int af,
483
 
                                   int type,
484
 
                                   int proto,
485
 
                                   pj_sock_t *p_sock)
486
 
{
487
 
    TInt rc;
488
 
 
489
 
    PJ_CHECK_STACK();
490
 
 
491
 
    /* Sanity checks. */
492
 
    PJ_ASSERT_RETURN(p_sock!=NULL, PJ_EINVAL);
493
 
 
494
 
    // Return failure if access point is marked as down by app.
495
 
    PJ_SYMBIAN_CHECK_CONNECTION();
496
 
 
497
 
    /* Set proto if none is specified. */
498
 
    if (proto == 0) {
499
 
        if (type == pj_SOCK_STREAM())
500
 
            proto = KProtocolInetTcp;
501
 
        else if (type == pj_SOCK_DGRAM())
502
 
            proto = KProtocolInetUdp;
503
 
    }
504
 
 
505
 
    /* Create Symbian RSocket */
506
 
    RSocket rSock;
507
 
    if (PjSymbianOS::Instance()->Connection())
508
 
        rc = rSock.Open(PjSymbianOS::Instance()->SocketServ(),
509
 
                        af, type, proto,
510
 
                        *PjSymbianOS::Instance()->Connection());
511
 
    else
512
 
        rc = rSock.Open(PjSymbianOS::Instance()->SocketServ(),
513
 
                        af, type, proto);
514
 
 
515
 
    if (rc != KErrNone)
516
 
        return PJ_RETURN_OS_ERROR(rc);
517
 
 
518
 
 
519
 
    /* Wrap Symbian RSocket into PJLIB's CPjSocket, and return to caller */
520
 
    CPjSocket *pjSock = new CPjSocket(af, type, rSock);
521
 
    *p_sock = (pj_sock_t)pjSock;
522
 
 
523
 
    return PJ_SUCCESS;
524
 
}
525
 
 
526
 
 
527
 
/*
528
 
 * Bind socket.
529
 
 */
530
 
PJ_DEF(pj_status_t) pj_sock_bind( pj_sock_t sock,
531
 
                                  const pj_sockaddr_t *addr,
532
 
                                  int len)
533
 
{
534
 
    pj_status_t status;
535
 
    TInt rc;
536
 
 
537
 
    PJ_CHECK_STACK();
538
 
 
539
 
    PJ_ASSERT_RETURN(sock != 0, PJ_EINVAL);
540
 
    PJ_ASSERT_RETURN(addr && len>=(int)sizeof(pj_sockaddr_in), PJ_EINVAL);
541
 
 
542
 
    // Convert PJLIB's pj_sockaddr into Symbian's TInetAddr
543
 
    TInetAddr inetAddr;
544
 
    status = PjSymbianOS::pj2Addr(*(pj_sockaddr*)addr, len, inetAddr);
545
 
    if (status != PJ_SUCCESS)
546
 
        return status;
547
 
 
548
 
    // Get the RSocket instance
549
 
    RSocket &rSock = ((CPjSocket*)sock)->Socket();
550
 
 
551
 
    // Bind
552
 
    rc = rSock.Bind(inetAddr);
553
 
 
554
 
    return (rc==KErrNone) ? PJ_SUCCESS : PJ_RETURN_OS_ERROR(rc);
555
 
}
556
 
 
557
 
 
558
 
/*
559
 
 * Bind socket.
560
 
 */
561
 
PJ_DEF(pj_status_t) pj_sock_bind_in( pj_sock_t sock,
562
 
                                     pj_uint32_t addr32,
563
 
                                     pj_uint16_t port)
564
 
{
565
 
    pj_sockaddr_in addr;
566
 
 
567
 
    PJ_CHECK_STACK();
568
 
 
569
 
    pj_bzero(&addr, sizeof(addr));
570
 
    addr.sin_family = PJ_AF_INET;
571
 
    addr.sin_addr.s_addr = pj_htonl(addr32);
572
 
    addr.sin_port = pj_htons(port);
573
 
 
574
 
    return pj_sock_bind(sock, &addr, sizeof(pj_sockaddr_in));
575
 
}
576
 
 
577
 
 
578
 
/*
579
 
 * Close socket.
580
 
 */
581
 
PJ_DEF(pj_status_t) pj_sock_close(pj_sock_t sock)
582
 
{
583
 
    PJ_CHECK_STACK();
584
 
 
585
 
    PJ_ASSERT_RETURN(sock != 0, PJ_EINVAL);
586
 
 
587
 
    CPjSocket *pjSock = (CPjSocket*)sock;
588
 
 
589
 
    // This will close the socket.
590
 
    delete pjSock;
591
 
 
592
 
    return PJ_SUCCESS;
593
 
}
594
 
 
595
 
/*
596
 
 * Get remote's name.
597
 
 */
598
 
PJ_DEF(pj_status_t) pj_sock_getpeername( pj_sock_t sock,
599
 
                                         pj_sockaddr_t *addr,
600
 
                                         int *namelen)
601
 
{
602
 
    PJ_CHECK_STACK();
603
 
 
604
 
    PJ_ASSERT_RETURN(sock && addr && namelen &&
605
 
                     *namelen>=(int)sizeof(pj_sockaddr_in), PJ_EINVAL);
606
 
 
607
 
    CPjSocket *pjSock = (CPjSocket*)sock;
608
 
    RSocket &rSock = pjSock->Socket();
609
 
 
610
 
    // Socket must be connected.
611
 
    PJ_ASSERT_RETURN(pjSock->IsConnected(), PJ_EINVALIDOP);
612
 
 
613
 
    TInetAddr inetAddr;
614
 
    rSock.RemoteName(inetAddr);
615
 
 
616
 
    return PjSymbianOS::Addr2pj(inetAddr, *(pj_sockaddr*)addr, namelen);
617
 
}
618
 
 
619
 
/*
620
 
 * Get socket name.
621
 
 */
622
 
PJ_DEF(pj_status_t) pj_sock_getsockname( pj_sock_t sock,
623
 
                                         pj_sockaddr_t *addr,
624
 
                                         int *namelen)
625
 
{
626
 
    PJ_CHECK_STACK();
627
 
 
628
 
    PJ_ASSERT_RETURN(sock && addr && namelen &&
629
 
                     *namelen>=(int)sizeof(pj_sockaddr_in), PJ_EINVAL);
630
 
 
631
 
    CPjSocket *pjSock = (CPjSocket*)sock;
632
 
    RSocket &rSock = pjSock->Socket();
633
 
 
634
 
    TInetAddr inetAddr;
635
 
    rSock.LocalName(inetAddr);
636
 
 
637
 
    return PjSymbianOS::Addr2pj(inetAddr, *(pj_sockaddr*)addr, namelen);
638
 
}
639
 
 
640
 
/*
641
 
 * Send data
642
 
 */
643
 
PJ_DEF(pj_status_t) pj_sock_send(pj_sock_t sock,
644
 
                                 const void *buf,
645
 
                                 pj_ssize_t *len,
646
 
                                 unsigned flags)
647
 
{
648
 
    PJ_CHECK_STACK();
649
 
    PJ_ASSERT_RETURN(sock && buf && len, PJ_EINVAL);
650
 
 
651
 
    // Return failure if access point is marked as down by app.
652
 
    PJ_SYMBIAN_CHECK_CONNECTION();
653
 
 
654
 
    CPjSocket *pjSock = (CPjSocket*)sock;
655
 
    RSocket &rSock = pjSock->Socket();
656
 
 
657
 
    // send() should only be called to connected socket
658
 
    PJ_ASSERT_RETURN(pjSock->IsConnected(), PJ_EINVALIDOP);
659
 
 
660
 
    TPtrC8 data((const TUint8*)buf, (TInt)*len);
661
 
    TRequestStatus reqStatus;
662
 
    TSockXfrLength sentLen;
663
 
 
664
 
    rSock.Send(data, flags, reqStatus, sentLen);
665
 
    User::WaitForRequest(reqStatus);
666
 
 
667
 
    if (reqStatus.Int()==KErrNone) {
668
 
        //*len = (TInt) sentLen.Length();
669
 
        return PJ_SUCCESS;
670
 
    } else
671
 
        return PJ_RETURN_OS_ERROR(reqStatus.Int());
672
 
}
673
 
 
674
 
 
675
 
/*
676
 
 * Send data.
677
 
 */
678
 
PJ_DEF(pj_status_t) pj_sock_sendto(pj_sock_t sock,
679
 
                                   const void *buf,
680
 
                                   pj_ssize_t *len,
681
 
                                   unsigned flags,
682
 
                                   const pj_sockaddr_t *to,
683
 
                                   int tolen)
684
 
{
685
 
    pj_status_t status;
686
 
 
687
 
    PJ_CHECK_STACK();
688
 
    PJ_ASSERT_RETURN(sock && buf && len, PJ_EINVAL);
689
 
 
690
 
    // Return failure if access point is marked as down by app.
691
 
    PJ_SYMBIAN_CHECK_CONNECTION();
692
 
 
693
 
    CPjSocket *pjSock = (CPjSocket*)sock;
694
 
    RSocket &rSock = pjSock->Socket();
695
 
 
696
 
    // Only supports AF_INET for now
697
 
    PJ_ASSERT_RETURN(tolen>=(int)sizeof(pj_sockaddr_in), PJ_EINVAL);
698
 
 
699
 
    TInetAddr inetAddr;
700
 
    status = PjSymbianOS::pj2Addr(*(pj_sockaddr*)to, tolen, inetAddr);
701
 
    if (status != PJ_SUCCESS)
702
 
        return status;
703
 
 
704
 
    TPtrC8 data((const TUint8*)buf, (TInt)*len);
705
 
    TRequestStatus reqStatus;
706
 
    TSockXfrLength sentLen;
707
 
 
708
 
    rSock.SendTo(data, inetAddr, flags, reqStatus, sentLen);
709
 
    User::WaitForRequest(reqStatus);
710
 
 
711
 
    if (reqStatus.Int()==KErrNone) {
712
 
        //For some reason TSockXfrLength is not returning correctly!
713
 
        //*len = (TInt) sentLen.Length();
714
 
        return PJ_SUCCESS;
715
 
    } else
716
 
        return PJ_RETURN_OS_ERROR(reqStatus.Int());
717
 
}
718
 
 
719
 
/*
720
 
 * Receive data.
721
 
 */
722
 
PJ_DEF(pj_status_t) pj_sock_recv(pj_sock_t sock,
723
 
                                 void *buf,
724
 
                                 pj_ssize_t *len,
725
 
                                 unsigned flags)
726
 
{
727
 
    PJ_CHECK_STACK();
728
 
 
729
 
    PJ_ASSERT_RETURN(sock && buf && len, PJ_EINVAL);
730
 
    PJ_ASSERT_RETURN(*len > 0, PJ_EINVAL);
731
 
 
732
 
    // Return failure if access point is marked as down by app.
733
 
    PJ_SYMBIAN_CHECK_CONNECTION();
734
 
 
735
 
    CPjSocket *pjSock = (CPjSocket*)sock;
736
 
 
737
 
    if (pjSock->Reader()) {
738
 
        CPjSocketReader *reader = pjSock->Reader();
739
 
 
740
 
        while (reader->IsActive() && !reader->HasData()) {
741
 
            User::WaitForAnyRequest();
742
 
        }
743
 
 
744
 
        if (reader->HasData()) {
745
 
            TPtr8 data((TUint8*)buf, (TInt)*len);
746
 
            TInetAddr inetAddr;
747
 
 
748
 
            reader->ReadData(data, &inetAddr);
749
 
 
750
 
            *len = data.Length();
751
 
            return PJ_SUCCESS;
752
 
        }
753
 
    }
754
 
 
755
 
    TRequestStatus reqStatus;
756
 
    TSockXfrLength recvLen;
757
 
    TPtr8 data((TUint8*)buf, (TInt)*len, (TInt)*len);
758
 
 
759
 
    if (pjSock->IsDatagram()) {
760
 
        pjSock->Socket().Recv(data, flags, reqStatus);
761
 
    } else {
762
 
        // Using static like this is not pretty, but we don't need to use
763
 
        // the value anyway, hence doing it like this is probably most
764
 
        // optimal.
765
 
        static TSockXfrLength len;
766
 
        pjSock->Socket().RecvOneOrMore(data, flags, reqStatus, len);
767
 
    }
768
 
    User::WaitForRequest(reqStatus);
769
 
 
770
 
    if (reqStatus == KErrNone) {
771
 
        //*len = (TInt)recvLen.Length();
772
 
        *len = data.Length();
773
 
        return PJ_SUCCESS;
774
 
    } else {
775
 
        *len = -1;
776
 
        return PJ_RETURN_OS_ERROR(reqStatus.Int());
777
 
    }
778
 
}
779
 
 
780
 
/*
781
 
 * Receive data.
782
 
 */
783
 
PJ_DEF(pj_status_t) pj_sock_recvfrom(pj_sock_t sock,
784
 
                                     void *buf,
785
 
                                     pj_ssize_t *len,
786
 
                                     unsigned flags,
787
 
                                     pj_sockaddr_t *from,
788
 
                                     int *fromlen)
789
 
{
790
 
    PJ_CHECK_STACK();
791
 
 
792
 
    PJ_ASSERT_RETURN(sock && buf && len && from && fromlen, PJ_EINVAL);
793
 
    PJ_ASSERT_RETURN(*len > 0, PJ_EINVAL);
794
 
    PJ_ASSERT_RETURN(*fromlen >= (int)sizeof(pj_sockaddr_in), PJ_EINVAL);
795
 
 
796
 
    // Return failure if access point is marked as down by app.
797
 
    PJ_SYMBIAN_CHECK_CONNECTION();
798
 
 
799
 
    CPjSocket *pjSock = (CPjSocket*)sock;
800
 
    RSocket &rSock = pjSock->Socket();
801
 
 
802
 
    if (pjSock->Reader()) {
803
 
        CPjSocketReader *reader = pjSock->Reader();
804
 
 
805
 
        while (reader->IsActive() && !reader->HasData()) {
806
 
            User::WaitForAnyRequest();
807
 
        }
808
 
 
809
 
        if (reader->HasData()) {
810
 
            TPtr8 data((TUint8*)buf, (TInt)*len);
811
 
            TInetAddr inetAddr;
812
 
 
813
 
            reader->ReadData(data, &inetAddr);
814
 
 
815
 
            *len = data.Length();
816
 
 
817
 
            if (from && fromlen) {
818
 
                return PjSymbianOS::Addr2pj(inetAddr, *(pj_sockaddr*)from,
819
 
                                            fromlen);
820
 
            } else {
821
 
                return PJ_SUCCESS;
822
 
            }
823
 
        }
824
 
    }
825
 
 
826
 
    TInetAddr inetAddr;
827
 
    TRequestStatus reqStatus;
828
 
    TSockXfrLength recvLen;
829
 
    TPtr8 data((TUint8*)buf, (TInt)*len, (TInt)*len);
830
 
 
831
 
    rSock.RecvFrom(data, inetAddr, flags, reqStatus, recvLen);
832
 
    User::WaitForRequest(reqStatus);
833
 
 
834
 
    if (reqStatus == KErrNone) {
835
 
        //*len = (TInt)recvLen.Length();
836
 
        *len = data.Length();
837
 
        return PjSymbianOS::Addr2pj(inetAddr, *(pj_sockaddr*)from, fromlen);
838
 
    } else {
839
 
        *len = -1;
840
 
        *fromlen = -1;
841
 
        return PJ_RETURN_OS_ERROR(reqStatus.Int());
842
 
    }
843
 
}
844
 
 
845
 
/*
846
 
 * Get socket option.
847
 
 */
848
 
PJ_DEF(pj_status_t) pj_sock_getsockopt( pj_sock_t sock,
849
 
                                        pj_uint16_t level,
850
 
                                        pj_uint16_t optname,
851
 
                                        void *optval,
852
 
                                        int *optlen)
853
 
{
854
 
    // Not supported for now.
855
 
    PJ_UNUSED_ARG(sock);
856
 
    PJ_UNUSED_ARG(level);
857
 
    PJ_UNUSED_ARG(optname);
858
 
    PJ_UNUSED_ARG(optval);
859
 
    PJ_UNUSED_ARG(optlen);
860
 
    return PJ_EINVALIDOP;
861
 
}
862
 
 
863
 
/*
864
 
 * Set socket option.
865
 
 */
866
 
PJ_DEF(pj_status_t) pj_sock_setsockopt( pj_sock_t sock,
867
 
                                        pj_uint16_t level,
868
 
                                        pj_uint16_t optname,
869
 
                                        const void *optval,
870
 
                                        int optlen)
871
 
{
872
 
    // Not supported for now.
873
 
    PJ_UNUSED_ARG(sock);
874
 
    PJ_UNUSED_ARG(level);
875
 
    PJ_UNUSED_ARG(optname);
876
 
    PJ_UNUSED_ARG(optval);
877
 
    PJ_UNUSED_ARG(optlen);
878
 
    return PJ_EINVALIDOP;
879
 
}
880
 
 
881
 
/*
882
 
 * Connect socket.
883
 
 */
884
 
PJ_DEF(pj_status_t) pj_sock_connect( pj_sock_t sock,
885
 
                                     const pj_sockaddr_t *addr,
886
 
                                     int namelen)
887
 
{
888
 
    pj_status_t status;
889
 
 
890
 
    PJ_CHECK_STACK();
891
 
 
892
 
    PJ_ASSERT_RETURN(sock && addr && namelen, PJ_EINVAL);
893
 
    PJ_ASSERT_RETURN(((pj_sockaddr*)addr)->addr.sa_family == PJ_AF_INET,
894
 
                     PJ_EINVAL);
895
 
 
896
 
    // Return failure if access point is marked as down by app.
897
 
    PJ_SYMBIAN_CHECK_CONNECTION();
898
 
 
899
 
    CPjSocket *pjSock = (CPjSocket*)sock;
900
 
    RSocket &rSock = pjSock->Socket();
901
 
 
902
 
    TInetAddr inetAddr;
903
 
    TRequestStatus reqStatus;
904
 
 
905
 
    status = PjSymbianOS::pj2Addr(*(pj_sockaddr*)addr, namelen, inetAddr);
906
 
    if (status != PJ_SUCCESS)
907
 
        return status;
908
 
 
909
 
    rSock.Connect(inetAddr, reqStatus);
910
 
    User::WaitForRequest(reqStatus);
911
 
 
912
 
    if (reqStatus == KErrNone) {
913
 
        pjSock->SetConnected(true);
914
 
        return PJ_SUCCESS;
915
 
    } else {
916
 
        return PJ_RETURN_OS_ERROR(reqStatus.Int());
917
 
    }
918
 
}
919
 
 
920
 
 
921
 
/*
922
 
 * Shutdown socket.
923
 
 */
924
 
#if PJ_HAS_TCP
925
 
PJ_DEF(pj_status_t) pj_sock_shutdown( pj_sock_t sock,
926
 
                                      int how)
927
 
{
928
 
    PJ_CHECK_STACK();
929
 
 
930
 
    PJ_ASSERT_RETURN(sock, PJ_EINVAL);
931
 
 
932
 
    CPjSocket *pjSock = (CPjSocket*)sock;
933
 
    RSocket &rSock = pjSock->Socket();
934
 
 
935
 
    RSocket::TShutdown aHow;
936
 
    if (how == PJ_SD_RECEIVE)
937
 
        aHow = RSocket::EStopInput;
938
 
    else if (how == PJ_SHUT_WR)
939
 
        aHow = RSocket::EStopOutput;
940
 
    else
941
 
        aHow = RSocket::ENormal;
942
 
 
943
 
    TRequestStatus reqStatus;
944
 
 
945
 
    rSock.Shutdown(aHow, reqStatus);
946
 
    User::WaitForRequest(reqStatus);
947
 
 
948
 
    if (reqStatus == KErrNone) {
949
 
        return PJ_SUCCESS;
950
 
    } else {
951
 
        return PJ_RETURN_OS_ERROR(reqStatus.Int());
952
 
    }
953
 
}
954
 
 
955
 
/*
956
 
 * Start listening to incoming connections.
957
 
 */
958
 
PJ_DEF(pj_status_t) pj_sock_listen( pj_sock_t sock,
959
 
                                    int backlog)
960
 
{
961
 
    PJ_CHECK_STACK();
962
 
 
963
 
    PJ_ASSERT_RETURN(sock && backlog, PJ_EINVAL);
964
 
 
965
 
    CPjSocket *pjSock = (CPjSocket*)sock;
966
 
    RSocket &rSock = pjSock->Socket();
967
 
 
968
 
    TInt rc = rSock.Listen((TUint)backlog);
969
 
 
970
 
    if (rc == KErrNone) {
971
 
        return PJ_SUCCESS;
972
 
    } else {
973
 
        return PJ_RETURN_OS_ERROR(rc);
974
 
    }
975
 
}
976
 
 
977
 
/*
978
 
 * Accept incoming connections
979
 
 */
980
 
PJ_DEF(pj_status_t) pj_sock_accept( pj_sock_t serverfd,
981
 
                                    pj_sock_t *newsock,
982
 
                                    pj_sockaddr_t *addr,
983
 
                                    int *addrlen)
984
 
{
985
 
    PJ_CHECK_STACK();
986
 
 
987
 
    PJ_ASSERT_RETURN(serverfd && newsock, PJ_EINVAL);
988
 
 
989
 
    CPjSocket *pjSock = (CPjSocket*)serverfd;
990
 
    RSocket &rSock = pjSock->Socket();
991
 
 
992
 
    // Create a 'blank' socket
993
 
    RSocket newSock;
994
 
    newSock.Open(PjSymbianOS::Instance()->SocketServ());
995
 
 
996
 
    // Call Accept()
997
 
    TRequestStatus reqStatus;
998
 
 
999
 
    rSock.Accept(newSock, reqStatus);
1000
 
    User::WaitForRequest(reqStatus);
1001
 
 
1002
 
    if (reqStatus != KErrNone) {
1003
 
        return PJ_RETURN_OS_ERROR(reqStatus.Int());
1004
 
    }
1005
 
 
1006
 
    // Create PJ socket
1007
 
    CPjSocket *newPjSock = new CPjSocket(pjSock->GetAf(), pjSock->GetSockType(),
1008
 
                                         newSock);
1009
 
    newPjSock->SetConnected(true);
1010
 
 
1011
 
    *newsock = (pj_sock_t) newPjSock;
1012
 
 
1013
 
    if (addr && addrlen) {
1014
 
        return pj_sock_getpeername(*newsock, addr, addrlen);
1015
 
    }
1016
 
 
1017
 
    return PJ_SUCCESS;
1018
 
}
1019
 
#endif  /* PJ_HAS_TCP */