| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/http/mock_gssapi_library_posix.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/strings/string_util.h" | |
| 9 #include "base/strings/stringprintf.h" | |
| 10 #include "testing/gtest/include/gtest/gtest.h" | |
| 11 | |
| 12 namespace net { | |
| 13 | |
| 14 namespace test { | |
| 15 | |
| 16 struct GssNameMockImpl { | |
| 17 std::string name; | |
| 18 gss_OID_desc name_type; | |
| 19 }; | |
| 20 | |
| 21 } // namespace test | |
| 22 | |
| 23 namespace { | |
| 24 | |
| 25 // gss_OID helpers. | |
| 26 // NOTE: gss_OID's do not own the data they point to, which should be static. | |
| 27 void ClearOid(gss_OID dest) { | |
| 28 if (!dest) | |
| 29 return; | |
| 30 dest->length = 0; | |
| 31 dest->elements = NULL; | |
| 32 } | |
| 33 | |
| 34 void SetOid(gss_OID dest, const void* src, size_t length) { | |
| 35 if (!dest) | |
| 36 return; | |
| 37 ClearOid(dest); | |
| 38 if (!src) | |
| 39 return; | |
| 40 dest->length = length; | |
| 41 if (length) | |
| 42 dest->elements = const_cast<void*>(src); | |
| 43 } | |
| 44 | |
| 45 void CopyOid(gss_OID dest, const gss_OID_desc* src) { | |
| 46 if (!dest) | |
| 47 return; | |
| 48 ClearOid(dest); | |
| 49 if (!src) | |
| 50 return; | |
| 51 SetOid(dest, src->elements, src->length); | |
| 52 } | |
| 53 | |
| 54 // gss_buffer_t helpers. | |
| 55 void ClearBuffer(gss_buffer_t dest) { | |
| 56 if (!dest) | |
| 57 return; | |
| 58 dest->length = 0; | |
| 59 delete [] reinterpret_cast<char*>(dest->value); | |
| 60 dest->value = NULL; | |
| 61 } | |
| 62 | |
| 63 void SetBuffer(gss_buffer_t dest, const void* src, size_t length) { | |
| 64 if (!dest) | |
| 65 return; | |
| 66 ClearBuffer(dest); | |
| 67 if (!src) | |
| 68 return; | |
| 69 dest->length = length; | |
| 70 if (length) { | |
| 71 dest->value = new char[length]; | |
| 72 memcpy(dest->value, src, length); | |
| 73 } | |
| 74 } | |
| 75 | |
| 76 void CopyBuffer(gss_buffer_t dest, const gss_buffer_t src) { | |
| 77 if (!dest) | |
| 78 return; | |
| 79 ClearBuffer(dest); | |
| 80 if (!src) | |
| 81 return; | |
| 82 SetBuffer(dest, src->value, src->length); | |
| 83 } | |
| 84 | |
| 85 std::string BufferToString(const gss_buffer_t src) { | |
| 86 std::string dest; | |
| 87 if (!src) | |
| 88 return dest; | |
| 89 const char* string = reinterpret_cast<char*>(src->value); | |
| 90 dest.assign(string, src->length); | |
| 91 return dest; | |
| 92 } | |
| 93 | |
| 94 void BufferFromString(const std::string& src, gss_buffer_t dest) { | |
| 95 if (!dest) | |
| 96 return; | |
| 97 SetBuffer(dest, src.c_str(), src.length()); | |
| 98 } | |
| 99 | |
| 100 // gss_name_t helpers. | |
| 101 void ClearName(gss_name_t dest) { | |
| 102 if (!dest) | |
| 103 return; | |
| 104 test::GssNameMockImpl* name = reinterpret_cast<test::GssNameMockImpl*>(dest); | |
| 105 name->name.clear(); | |
| 106 ClearOid(&name->name_type); | |
| 107 } | |
| 108 | |
| 109 void SetName(gss_name_t dest, const void* src, size_t length) { | |
| 110 if (!dest) | |
| 111 return; | |
| 112 ClearName(dest); | |
| 113 if (!src) | |
| 114 return; | |
| 115 test::GssNameMockImpl* name = reinterpret_cast<test::GssNameMockImpl*>(dest); | |
| 116 name->name.assign(reinterpret_cast<const char*>(src), length); | |
| 117 } | |
| 118 | |
| 119 std::string NameToString(const gss_name_t& src) { | |
| 120 std::string dest; | |
| 121 if (!src) | |
| 122 return dest; | |
| 123 test::GssNameMockImpl* string = | |
| 124 reinterpret_cast<test::GssNameMockImpl*>(src); | |
| 125 dest = string->name; | |
| 126 return dest; | |
| 127 } | |
| 128 | |
| 129 void NameFromString(const std::string& src, gss_name_t dest) { | |
| 130 if (!dest) | |
| 131 return; | |
| 132 SetName(dest, src.c_str(), src.length()); | |
| 133 } | |
| 134 | |
| 135 } // namespace | |
| 136 | |
| 137 namespace test { | |
| 138 | |
| 139 GssContextMockImpl::GssContextMockImpl() | |
| 140 : lifetime_rec(0), | |
| 141 ctx_flags(0), | |
| 142 locally_initiated(0), | |
| 143 open(0) { | |
| 144 ClearOid(&mech_type); | |
| 145 } | |
| 146 | |
| 147 GssContextMockImpl::GssContextMockImpl(const GssContextMockImpl& other) | |
| 148 : src_name(other.src_name), | |
| 149 targ_name(other.targ_name), | |
| 150 lifetime_rec(other.lifetime_rec), | |
| 151 ctx_flags(other.ctx_flags), | |
| 152 locally_initiated(other.locally_initiated), | |
| 153 open(other.open) { | |
| 154 CopyOid(&mech_type, &other.mech_type); | |
| 155 } | |
| 156 | |
| 157 GssContextMockImpl::GssContextMockImpl(const char* src_name_in, | |
| 158 const char* targ_name_in, | |
| 159 OM_uint32 lifetime_rec_in, | |
| 160 const gss_OID_desc& mech_type_in, | |
| 161 OM_uint32 ctx_flags_in, | |
| 162 int locally_initiated_in, | |
| 163 int open_in) | |
| 164 : src_name(src_name_in ? src_name_in : ""), | |
| 165 targ_name(targ_name_in ? targ_name_in : ""), | |
| 166 lifetime_rec(lifetime_rec_in), | |
| 167 ctx_flags(ctx_flags_in), | |
| 168 locally_initiated(locally_initiated_in), | |
| 169 open(open_in) { | |
| 170 CopyOid(&mech_type, &mech_type_in); | |
| 171 } | |
| 172 | |
| 173 GssContextMockImpl::~GssContextMockImpl() { | |
| 174 ClearOid(&mech_type); | |
| 175 } | |
| 176 | |
| 177 void GssContextMockImpl::Assign( | |
| 178 const GssContextMockImpl& other) { | |
| 179 if (&other == this) | |
| 180 return; | |
| 181 src_name = other.src_name; | |
| 182 targ_name = other.targ_name; | |
| 183 lifetime_rec = other.lifetime_rec; | |
| 184 CopyOid(&mech_type, &other.mech_type); | |
| 185 ctx_flags = other.ctx_flags; | |
| 186 locally_initiated = other.locally_initiated; | |
| 187 open = other.open; | |
| 188 } | |
| 189 | |
| 190 MockGSSAPILibrary::SecurityContextQuery::SecurityContextQuery() | |
| 191 : expected_package(), | |
| 192 response_code(0), | |
| 193 minor_response_code(0), | |
| 194 context_info() { | |
| 195 expected_input_token.length = 0; | |
| 196 expected_input_token.value = NULL; | |
| 197 output_token.length = 0; | |
| 198 output_token.value = NULL; | |
| 199 } | |
| 200 | |
| 201 MockGSSAPILibrary::SecurityContextQuery::SecurityContextQuery( | |
| 202 const std::string& in_expected_package, | |
| 203 OM_uint32 in_response_code, | |
| 204 OM_uint32 in_minor_response_code, | |
| 205 const test::GssContextMockImpl& in_context_info, | |
| 206 const char* in_expected_input_token, | |
| 207 const char* in_output_token) | |
| 208 : expected_package(in_expected_package), | |
| 209 response_code(in_response_code), | |
| 210 minor_response_code(in_minor_response_code), | |
| 211 context_info(in_context_info) { | |
| 212 if (in_expected_input_token) { | |
| 213 expected_input_token.length = strlen(in_expected_input_token); | |
| 214 expected_input_token.value = const_cast<char*>(in_expected_input_token); | |
| 215 } else { | |
| 216 expected_input_token.length = 0; | |
| 217 expected_input_token.value = NULL; | |
| 218 } | |
| 219 | |
| 220 if (in_output_token) { | |
| 221 output_token.length = strlen(in_output_token); | |
| 222 output_token.value = const_cast<char*>(in_output_token); | |
| 223 } else { | |
| 224 output_token.length = 0; | |
| 225 output_token.value = NULL; | |
| 226 } | |
| 227 } | |
| 228 | |
| 229 MockGSSAPILibrary::SecurityContextQuery::~SecurityContextQuery() {} | |
| 230 | |
| 231 MockGSSAPILibrary::MockGSSAPILibrary() { | |
| 232 } | |
| 233 | |
| 234 MockGSSAPILibrary::~MockGSSAPILibrary() { | |
| 235 } | |
| 236 | |
| 237 void MockGSSAPILibrary::ExpectSecurityContext( | |
| 238 const std::string& expected_package, | |
| 239 OM_uint32 response_code, | |
| 240 OM_uint32 minor_response_code, | |
| 241 const GssContextMockImpl& context_info, | |
| 242 const gss_buffer_desc& expected_input_token, | |
| 243 const gss_buffer_desc& output_token) { | |
| 244 SecurityContextQuery security_query; | |
| 245 security_query.expected_package = expected_package; | |
| 246 security_query.response_code = response_code; | |
| 247 security_query.minor_response_code = minor_response_code; | |
| 248 security_query.context_info.Assign(context_info); | |
| 249 security_query.expected_input_token = expected_input_token; | |
| 250 security_query.output_token = output_token; | |
| 251 expected_security_queries_.push_back(security_query); | |
| 252 } | |
| 253 | |
| 254 bool MockGSSAPILibrary::Init() { | |
| 255 return true; | |
| 256 } | |
| 257 | |
| 258 // These methods match the ones in the GSSAPI library. | |
| 259 OM_uint32 MockGSSAPILibrary::import_name( | |
| 260 OM_uint32* minor_status, | |
| 261 const gss_buffer_t input_name_buffer, | |
| 262 const gss_OID input_name_type, | |
| 263 gss_name_t* output_name) { | |
| 264 if (minor_status) | |
| 265 *minor_status = 0; | |
| 266 if (!output_name) | |
| 267 return GSS_S_BAD_NAME; | |
| 268 if (!input_name_buffer) | |
| 269 return GSS_S_CALL_BAD_STRUCTURE; | |
| 270 if (!input_name_type) | |
| 271 return GSS_S_BAD_NAMETYPE; | |
| 272 GssNameMockImpl* output = new GssNameMockImpl; | |
| 273 if (output == NULL) | |
| 274 return GSS_S_FAILURE; | |
| 275 output->name_type.length = 0; | |
| 276 output->name_type.elements = NULL; | |
| 277 | |
| 278 // Save the data. | |
| 279 output->name = BufferToString(input_name_buffer); | |
| 280 CopyOid(&output->name_type, input_name_type); | |
| 281 *output_name = reinterpret_cast<gss_name_t>(output); | |
| 282 | |
| 283 return GSS_S_COMPLETE; | |
| 284 } | |
| 285 | |
| 286 OM_uint32 MockGSSAPILibrary::release_name( | |
| 287 OM_uint32* minor_status, | |
| 288 gss_name_t* input_name) { | |
| 289 if (minor_status) | |
| 290 *minor_status = 0; | |
| 291 if (!input_name) | |
| 292 return GSS_S_BAD_NAME; | |
| 293 if (!*input_name) | |
| 294 return GSS_S_COMPLETE; | |
| 295 GssNameMockImpl* name = *reinterpret_cast<GssNameMockImpl**>(input_name); | |
| 296 ClearName(*input_name); | |
| 297 delete name; | |
| 298 *input_name = NULL; | |
| 299 return GSS_S_COMPLETE; | |
| 300 } | |
| 301 | |
| 302 OM_uint32 MockGSSAPILibrary::release_buffer( | |
| 303 OM_uint32* minor_status, | |
| 304 gss_buffer_t buffer) { | |
| 305 if (minor_status) | |
| 306 *minor_status = 0; | |
| 307 if (!buffer) | |
| 308 return GSS_S_BAD_NAME; | |
| 309 ClearBuffer(buffer); | |
| 310 return GSS_S_COMPLETE; | |
| 311 } | |
| 312 | |
| 313 OM_uint32 MockGSSAPILibrary::display_name( | |
| 314 OM_uint32* minor_status, | |
| 315 const gss_name_t input_name, | |
| 316 gss_buffer_t output_name_buffer, | |
| 317 gss_OID* output_name_type) { | |
| 318 if (minor_status) | |
| 319 *minor_status = 0; | |
| 320 if (!input_name) | |
| 321 return GSS_S_BAD_NAME; | |
| 322 if (!output_name_buffer) | |
| 323 return GSS_S_CALL_BAD_STRUCTURE; | |
| 324 if (!output_name_type) | |
| 325 return GSS_S_CALL_BAD_STRUCTURE; | |
| 326 std::string name(NameToString(input_name)); | |
| 327 BufferFromString(name, output_name_buffer); | |
| 328 GssNameMockImpl* internal_name = | |
| 329 *reinterpret_cast<GssNameMockImpl**>(input_name); | |
| 330 if (output_name_type) | |
| 331 *output_name_type = internal_name ? &internal_name->name_type : NULL; | |
| 332 return GSS_S_COMPLETE; | |
| 333 } | |
| 334 | |
| 335 OM_uint32 MockGSSAPILibrary::display_status( | |
| 336 OM_uint32* minor_status, | |
| 337 OM_uint32 status_value, | |
| 338 int status_type, | |
| 339 const gss_OID mech_type, | |
| 340 OM_uint32* message_context, | |
| 341 gss_buffer_t status_string) { | |
| 342 if (minor_status) | |
| 343 *minor_status = 0; | |
| 344 std::string msg = base::StringPrintf("Value: %u, Type %u", | |
| 345 status_value, | |
| 346 status_type); | |
| 347 if (message_context) | |
| 348 *message_context = 0; | |
| 349 BufferFromString(msg, status_string); | |
| 350 return GSS_S_COMPLETE; | |
| 351 } | |
| 352 | |
| 353 OM_uint32 MockGSSAPILibrary::init_sec_context( | |
| 354 OM_uint32* minor_status, | |
| 355 const gss_cred_id_t initiator_cred_handle, | |
| 356 gss_ctx_id_t* context_handle, | |
| 357 const gss_name_t target_name, | |
| 358 const gss_OID mech_type, | |
| 359 OM_uint32 req_flags, | |
| 360 OM_uint32 time_req, | |
| 361 const gss_channel_bindings_t input_chan_bindings, | |
| 362 const gss_buffer_t input_token, | |
| 363 gss_OID* actual_mech_type, | |
| 364 gss_buffer_t output_token, | |
| 365 OM_uint32* ret_flags, | |
| 366 OM_uint32* time_rec) { | |
| 367 if (minor_status) | |
| 368 *minor_status = 0; | |
| 369 if (!context_handle) | |
| 370 return GSS_S_CALL_BAD_STRUCTURE; | |
| 371 GssContextMockImpl** internal_context_handle = | |
| 372 reinterpret_cast<test::GssContextMockImpl**>(context_handle); | |
| 373 // Create it if necessary. | |
| 374 if (!*internal_context_handle) { | |
| 375 *internal_context_handle = new GssContextMockImpl; | |
| 376 } | |
| 377 EXPECT_TRUE(*internal_context_handle); | |
| 378 GssContextMockImpl& context = **internal_context_handle; | |
| 379 if (expected_security_queries_.empty()) { | |
| 380 return GSS_S_UNAVAILABLE; | |
| 381 } | |
| 382 SecurityContextQuery security_query = expected_security_queries_.front(); | |
| 383 expected_security_queries_.pop_front(); | |
| 384 EXPECT_EQ(std::string("Negotiate"), security_query.expected_package); | |
| 385 OM_uint32 major_status = security_query.response_code; | |
| 386 if (minor_status) | |
| 387 *minor_status = security_query.minor_response_code; | |
| 388 context.src_name = security_query.context_info.src_name; | |
| 389 context.targ_name = security_query.context_info.targ_name; | |
| 390 context.lifetime_rec = security_query.context_info.lifetime_rec; | |
| 391 CopyOid(&context.mech_type, &security_query.context_info.mech_type); | |
| 392 context.ctx_flags = security_query.context_info.ctx_flags; | |
| 393 context.locally_initiated = security_query.context_info.locally_initiated; | |
| 394 context.open = security_query.context_info.open; | |
| 395 if (!input_token) { | |
| 396 EXPECT_FALSE(security_query.expected_input_token.length); | |
| 397 } else { | |
| 398 EXPECT_EQ(input_token->length, security_query.expected_input_token.length); | |
| 399 if (input_token->length) { | |
| 400 EXPECT_EQ(0, memcmp(input_token->value, | |
| 401 security_query.expected_input_token.value, | |
| 402 input_token->length)); | |
| 403 } | |
| 404 } | |
| 405 CopyBuffer(output_token, &security_query.output_token); | |
| 406 if (actual_mech_type) | |
| 407 CopyOid(*actual_mech_type, mech_type); | |
| 408 if (ret_flags) | |
| 409 *ret_flags = req_flags; | |
| 410 return major_status; | |
| 411 } | |
| 412 | |
| 413 OM_uint32 MockGSSAPILibrary::wrap_size_limit( | |
| 414 OM_uint32* minor_status, | |
| 415 const gss_ctx_id_t context_handle, | |
| 416 int conf_req_flag, | |
| 417 gss_qop_t qop_req, | |
| 418 OM_uint32 req_output_size, | |
| 419 OM_uint32* max_input_size) { | |
| 420 if (minor_status) | |
| 421 *minor_status = 0; | |
| 422 ADD_FAILURE(); | |
| 423 return GSS_S_UNAVAILABLE; | |
| 424 } | |
| 425 | |
| 426 OM_uint32 MockGSSAPILibrary::delete_sec_context( | |
| 427 OM_uint32* minor_status, | |
| 428 gss_ctx_id_t* context_handle, | |
| 429 gss_buffer_t output_token) { | |
| 430 if (minor_status) | |
| 431 *minor_status = 0; | |
| 432 if (!context_handle) | |
| 433 return GSS_S_CALL_BAD_STRUCTURE; | |
| 434 GssContextMockImpl** internal_context_handle = | |
| 435 reinterpret_cast<GssContextMockImpl**>(context_handle); | |
| 436 if (*internal_context_handle) { | |
| 437 delete *internal_context_handle; | |
| 438 *internal_context_handle = NULL; | |
| 439 } | |
| 440 return GSS_S_COMPLETE; | |
| 441 } | |
| 442 | |
| 443 OM_uint32 MockGSSAPILibrary::inquire_context( | |
| 444 OM_uint32* minor_status, | |
| 445 const gss_ctx_id_t context_handle, | |
| 446 gss_name_t* src_name, | |
| 447 gss_name_t* targ_name, | |
| 448 OM_uint32* lifetime_rec, | |
| 449 gss_OID* mech_type, | |
| 450 OM_uint32* ctx_flags, | |
| 451 int* locally_initiated, | |
| 452 int* open) { | |
| 453 if (minor_status) | |
| 454 *minor_status = 0; | |
| 455 if (!context_handle) | |
| 456 return GSS_S_CALL_BAD_STRUCTURE; | |
| 457 GssContextMockImpl* internal_context_ptr = | |
| 458 reinterpret_cast<GssContextMockImpl*>(context_handle); | |
| 459 GssContextMockImpl& context = *internal_context_ptr; | |
| 460 if (src_name) | |
| 461 NameFromString(context.src_name, *src_name); | |
| 462 if (targ_name) | |
| 463 NameFromString(context.targ_name, *targ_name); | |
| 464 if (lifetime_rec) | |
| 465 *lifetime_rec = context.lifetime_rec; | |
| 466 if (mech_type) | |
| 467 CopyOid(*mech_type, &context.mech_type); | |
| 468 if (ctx_flags) | |
| 469 *ctx_flags = context.ctx_flags; | |
| 470 if (locally_initiated) | |
| 471 *locally_initiated = context.locally_initiated; | |
| 472 if (open) | |
| 473 *open = context.open; | |
| 474 return GSS_S_COMPLETE; | |
| 475 } | |
| 476 | |
| 477 } // namespace test | |
| 478 | |
| 479 } // namespace net | |
| 480 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master