![]() |
libzmq master
The Intelligent Transport Layer
|
00001 /* 00002 Copyright (c) 2009-2011 250bpm s.r.o. 00003 Copyright (c) 2007-2009 iMatix Corporation 00004 Copyright (c) 2011 VMware, Inc. 00005 Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file 00006 00007 This file is part of 0MQ. 00008 00009 0MQ is free software; you can redistribute it and/or modify it under 00010 the terms of the GNU Lesser General Public License as published by 00011 the Free Software Foundation; either version 3 of the License, or 00012 (at your option) any later version. 00013 00014 0MQ is distributed in the hope that it will be useful, 00015 but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 GNU Lesser General Public License for more details. 00018 00019 You should have received a copy of the GNU Lesser General Public License 00020 along with this program. If not, see <http://www.gnu.org/licenses/>. 00021 */ 00022 00023 #include <string.h> 00024 00025 #include "options.hpp" 00026 #include "err.hpp" 00027 00028 zmq::options_t::options_t () : 00029 sndhwm (1000), 00030 rcvhwm (1000), 00031 affinity (0), 00032 identity_size (0), 00033 rate (100), 00034 recovery_ivl (10000), 00035 multicast_hops (1), 00036 sndbuf (0), 00037 rcvbuf (0), 00038 type (-1), 00039 linger (-1), 00040 reconnect_ivl (100), 00041 reconnect_ivl_max (0), 00042 backlog (100), 00043 maxmsgsize (-1), 00044 rcvtimeo (-1), 00045 sndtimeo (-1), 00046 ipv4only (1), 00047 delay_on_close (true), 00048 delay_on_disconnect (true), 00049 filter (false), 00050 send_identity (false), 00051 recv_identity (false) 00052 { 00053 } 00054 00055 int zmq::options_t::setsockopt (int option_, const void *optval_, 00056 size_t optvallen_) 00057 { 00058 switch (option_) { 00059 00060 case ZMQ_SNDHWM: 00061 if (optvallen_ != sizeof (int) || *((int*) optval_) < 0) { 00062 errno = EINVAL; 00063 return -1; 00064 } 00065 sndhwm = *((int*) optval_); 00066 return 0; 00067 00068 case ZMQ_RCVHWM: 00069 if (optvallen_ != sizeof (int) || *((int*) optval_) < 0) { 00070 errno = EINVAL; 00071 return -1; 00072 } 00073 rcvhwm = *((int*) optval_); 00074 return 0; 00075 00076 case ZMQ_AFFINITY: 00077 if (optvallen_ != sizeof (uint64_t)) { 00078 errno = EINVAL; 00079 return -1; 00080 } 00081 affinity = *((uint64_t*) optval_); 00082 return 0; 00083 00084 case ZMQ_IDENTITY: 00085 00086 // Empty identity is invalid as well as identity longer than 00087 // 255 bytes. Identity starting with binary zero is invalid 00088 // as these are used for auto-generated identities. 00089 if (optvallen_ < 1 || optvallen_ > 255 || 00090 *((const unsigned char*) optval_) == 0) { 00091 errno = EINVAL; 00092 return -1; 00093 } 00094 identity_size = optvallen_; 00095 memcpy (identity, optval_, identity_size); 00096 return 0; 00097 00098 case ZMQ_RATE: 00099 if (optvallen_ != sizeof (int) || *((int*) optval_) <= 0) { 00100 errno = EINVAL; 00101 return -1; 00102 } 00103 rate = *((int*) optval_); 00104 return 0; 00105 00106 case ZMQ_RECOVERY_IVL: 00107 if (optvallen_ != sizeof (int) || *((int*) optval_) < 0) { 00108 errno = EINVAL; 00109 return -1; 00110 } 00111 recovery_ivl = *((int*) optval_); 00112 return 0; 00113 00114 case ZMQ_SNDBUF: 00115 if (optvallen_ != sizeof (int) || *((int*) optval_) < 0) { 00116 errno = EINVAL; 00117 return -1; 00118 } 00119 sndbuf = *((int*) optval_); 00120 return 0; 00121 00122 case ZMQ_RCVBUF: 00123 if (optvallen_ != sizeof (int) || *((int*) optval_) < 0) { 00124 errno = EINVAL; 00125 return -1; 00126 } 00127 rcvbuf = *((int*) optval_); 00128 return 0; 00129 00130 case ZMQ_LINGER: 00131 if (optvallen_ != sizeof (int)) { 00132 errno = EINVAL; 00133 return -1; 00134 } 00135 linger = *((int*) optval_); 00136 return 0; 00137 00138 case ZMQ_RECONNECT_IVL: 00139 if (optvallen_ != sizeof (int)) { 00140 errno = EINVAL; 00141 return -1; 00142 } 00143 if (*((int*) optval_) < 0) { 00144 errno = EINVAL; 00145 return -1; 00146 } 00147 reconnect_ivl = *((int*) optval_); 00148 return 0; 00149 00150 case ZMQ_RECONNECT_IVL_MAX: 00151 if (optvallen_ != sizeof (int)) { 00152 errno = EINVAL; 00153 return -1; 00154 } 00155 if (*((int*) optval_) < 0) { 00156 errno = EINVAL; 00157 return -1; 00158 } 00159 reconnect_ivl_max = *((int*) optval_); 00160 return 0; 00161 00162 case ZMQ_BACKLOG: 00163 if (optvallen_ != sizeof (int)) { 00164 errno = EINVAL; 00165 return -1; 00166 } 00167 backlog = *((int*) optval_); 00168 return 0; 00169 00170 case ZMQ_MAXMSGSIZE: 00171 if (optvallen_ != sizeof (int64_t)) { 00172 errno = EINVAL; 00173 return -1; 00174 } 00175 maxmsgsize = *((int64_t*) optval_); 00176 return 0; 00177 00178 case ZMQ_MULTICAST_HOPS: 00179 if (optvallen_ != sizeof (int) || *((int*) optval_) <= 0) { 00180 errno = EINVAL; 00181 return -1; 00182 } 00183 multicast_hops = *((int*) optval_); 00184 return 0; 00185 00186 case ZMQ_RCVTIMEO: 00187 if (optvallen_ != sizeof (int)) { 00188 errno = EINVAL; 00189 return -1; 00190 } 00191 rcvtimeo = *((int*) optval_); 00192 return 0; 00193 00194 case ZMQ_SNDTIMEO: 00195 if (optvallen_ != sizeof (int)) { 00196 errno = EINVAL; 00197 return -1; 00198 } 00199 sndtimeo = *((int*) optval_); 00200 return 0; 00201 00202 case ZMQ_IPV4ONLY: 00203 { 00204 if (optvallen_ != sizeof (int)) { 00205 errno = EINVAL; 00206 return -1; 00207 } 00208 int val = *((int*) optval_); 00209 if (val != 0 && val != 1) { 00210 errno = EINVAL; 00211 return -1; 00212 } 00213 ipv4only = val; 00214 return 0; 00215 } 00216 00217 } 00218 00219 errno = EINVAL; 00220 return -1; 00221 } 00222 00223 int zmq::options_t::getsockopt (int option_, void *optval_, size_t *optvallen_) 00224 { 00225 switch (option_) { 00226 00227 case ZMQ_SNDHWM: 00228 if (*optvallen_ < sizeof (int)) { 00229 errno = EINVAL; 00230 return -1; 00231 } 00232 *((int*) optval_) = sndhwm; 00233 *optvallen_ = sizeof (int); 00234 return 0; 00235 00236 case ZMQ_RCVHWM: 00237 if (*optvallen_ < sizeof (int)) { 00238 errno = EINVAL; 00239 return -1; 00240 } 00241 *((int*) optval_) = rcvhwm; 00242 *optvallen_ = sizeof (int); 00243 return 0; 00244 00245 case ZMQ_AFFINITY: 00246 if (*optvallen_ < sizeof (uint64_t)) { 00247 errno = EINVAL; 00248 return -1; 00249 } 00250 *((uint64_t*) optval_) = affinity; 00251 *optvallen_ = sizeof (uint64_t); 00252 return 0; 00253 00254 case ZMQ_IDENTITY: 00255 if (*optvallen_ < identity_size) { 00256 errno = EINVAL; 00257 return -1; 00258 } 00259 memcpy (optval_, identity, identity_size); 00260 *optvallen_ = identity_size; 00261 return 0; 00262 00263 case ZMQ_RATE: 00264 if (*optvallen_ < sizeof (int)) { 00265 errno = EINVAL; 00266 return -1; 00267 } 00268 *((int*) optval_) = rate; 00269 *optvallen_ = sizeof (int); 00270 return 0; 00271 00272 case ZMQ_RECOVERY_IVL: 00273 if (*optvallen_ < sizeof (int)) { 00274 errno = EINVAL; 00275 return -1; 00276 } 00277 *((int*) optval_) = recovery_ivl; 00278 *optvallen_ = sizeof (int); 00279 return 0; 00280 00281 case ZMQ_SNDBUF: 00282 if (*optvallen_ < sizeof (int)) { 00283 errno = EINVAL; 00284 return -1; 00285 } 00286 *((int*) optval_) = sndbuf; 00287 *optvallen_ = sizeof (int); 00288 return 0; 00289 00290 case ZMQ_RCVBUF: 00291 if (*optvallen_ < sizeof (int)) { 00292 errno = EINVAL; 00293 return -1; 00294 } 00295 *((int*) optval_) = rcvbuf; 00296 *optvallen_ = sizeof (int); 00297 return 0; 00298 00299 case ZMQ_TYPE: 00300 if (*optvallen_ < sizeof (int)) { 00301 errno = EINVAL; 00302 return -1; 00303 } 00304 *((int*) optval_) = type; 00305 *optvallen_ = sizeof (int); 00306 return 0; 00307 00308 case ZMQ_LINGER: 00309 if (*optvallen_ < sizeof (int)) { 00310 errno = EINVAL; 00311 return -1; 00312 } 00313 *((int*) optval_) = linger; 00314 *optvallen_ = sizeof (int); 00315 return 0; 00316 00317 case ZMQ_RECONNECT_IVL: 00318 if (*optvallen_ < sizeof (int)) { 00319 errno = EINVAL; 00320 return -1; 00321 } 00322 *((int*) optval_) = reconnect_ivl; 00323 *optvallen_ = sizeof (int); 00324 return 0; 00325 00326 case ZMQ_RECONNECT_IVL_MAX: 00327 if (*optvallen_ < sizeof (int)) { 00328 errno = EINVAL; 00329 return -1; 00330 } 00331 *((int*) optval_) = reconnect_ivl_max; 00332 *optvallen_ = sizeof (int); 00333 return 0; 00334 00335 case ZMQ_BACKLOG: 00336 if (*optvallen_ < sizeof (int)) { 00337 errno = EINVAL; 00338 return -1; 00339 } 00340 *((int*) optval_) = backlog; 00341 *optvallen_ = sizeof (int); 00342 return 0; 00343 00344 case ZMQ_MAXMSGSIZE: 00345 if (*optvallen_ < sizeof (int64_t)) { 00346 errno = EINVAL; 00347 return -1; 00348 } 00349 *((int64_t*) optval_) = maxmsgsize; 00350 *optvallen_ = sizeof (int64_t); 00351 return 0; 00352 00353 case ZMQ_MULTICAST_HOPS: 00354 if (*optvallen_ < sizeof (int)) { 00355 errno = EINVAL; 00356 return -1; 00357 } 00358 *((int*) optval_) = multicast_hops; 00359 *optvallen_ = sizeof (int); 00360 return 0; 00361 00362 case ZMQ_RCVTIMEO: 00363 if (*optvallen_ < sizeof (int)) { 00364 errno = EINVAL; 00365 return -1; 00366 } 00367 *((int*) optval_) = rcvtimeo; 00368 *optvallen_ = sizeof (int); 00369 return 0; 00370 00371 case ZMQ_SNDTIMEO: 00372 if (*optvallen_ < sizeof (int)) { 00373 errno = EINVAL; 00374 return -1; 00375 } 00376 *((int*) optval_) = sndtimeo; 00377 *optvallen_ = sizeof (int); 00378 return 0; 00379 00380 case ZMQ_IPV4ONLY: 00381 if (*optvallen_ < sizeof (int)) { 00382 errno = EINVAL; 00383 return -1; 00384 } 00385 *((int*) optval_) = ipv4only; 00386 *optvallen_ = sizeof (int); 00387 return 0; 00388 00389 } 00390 00391 errno = EINVAL; 00392 return -1; 00393 }