← Back to branch summary

~ubuntu-branches/ubuntu/trusty/serf/trusty-security

« back to all changes in this revision

Viewing changes to test/test_context.c

  • Committer: Bazaar Package Importer
  • Author(s): Peter Samuelson
  • Date: 2011-06-03 03:18:07 UTC
  • mfrom: (1.2.4 upstream)
  • mto: (3.3.1 sid)
  • mto: This revision was merged to the branch mainline in revision 11.
  • Revision ID: james.westby@ubuntu.com-20110603031807-3vq82t5lzw692our
Tags: 0.7.2-1
* New upstream release.
  - patches/no-export-vars: delete, now upstream.
* New ABI:
  - patches/abi-0.x: New patch to change upstream SONAME.
  - Rename libserf-0-0 to libserf0.7.
  - Rename libserf-0-0-dev to libserf-dev while we're at it.
* Policy 3.9.1: one instance of s/Conflicts/Breaks/.
* "Upgrade" to source format 1.0.
* Add some Depends: ${misc:Depends}; thanks, Lintian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_context.c
126
126
            return APR_EOF;
127
127
        }
128
128
 
 
129
        if (APR_STATUS_IS_EAGAIN(status)) {
 
130
            return status;
 
131
        }
 
132
 
129
133
    }
130
134
 
131
135
    return APR_SUCCESS;
141
145
    apr_pool_t *iter_pool;
142
146
    apr_array_header_t *accepted_requests, *handled_requests, *sent_requests;
143
147
    int i;
 
148
    test_server_message_t message_list[] = {
 
149
        {"GET / HTTP/1.1" CRLF
 
150
         "Transfer-Encoding: chunked" CRLF
 
151
         CRLF
 
152
         "1" CRLF
 
153
         "1" CRLF
 
154
         "0" CRLF
 
155
         CRLF},
 
156
        {"GET / HTTP/1.1" CRLF
 
157
         "Transfer-Encoding: chunked" CRLF
 
158
         "" CRLF
 
159
         "1" CRLF
 
160
         "2" CRLF
 
161
         "0" CRLF
 
162
         CRLF}
 
163
    };
 
164
 
144
165
    test_server_action_t action_list[] = {
145
 
        {SERVER_RECV,
146
 
        "GET / HTTP/1.1" CRLF
147
 
        "Transfer-Encoding: chunked" CRLF
148
 
        CRLF
149
 
        "1" CRLF
150
 
        "1" CRLF
151
 
        "0" CRLF
152
 
        CRLF
153
 
        "GET / HTTP/1.1" CRLF
154
 
        "Transfer-Encoding: chunked" CRLF
155
 
        "" CRLF
156
 
        "1" CRLF
157
 
        "2" CRLF
158
 
        "0" CRLF
159
 
        CRLF
160
 
        },
161
 
        {SERVER_SEND,
162
 
        "HTTP/1.1 200 OK" CRLF
163
 
        "Transfer-Encoding: chunked" CRLF
164
 
        CRLF
165
 
        "0" CRLF
166
 
        CRLF
167
 
        "HTTP/1.1 200 OK" CRLF
168
 
        "Transfer-Encoding: chunked" CRLF
169
 
        CRLF
170
 
        "0" CRLF
171
 
        CRLF
172
 
        }
 
166
        {SERVER_RESPOND,
 
167
         "HTTP/1.1 200 OK" CRLF
 
168
         "Transfer-Encoding: chunked" CRLF
 
169
         CRLF
 
170
         "0" CRLF
 
171
         CRLF},
 
172
        {SERVER_RESPOND,
 
173
         "HTTP/1.1 200 OK" CRLF
 
174
         "Transfer-Encoding: chunked" CRLF
 
175
         CRLF
 
176
         "0" CRLF
 
177
         CRLF}
173
178
    };
174
179
 
175
180
    accepted_requests = apr_array_make(test_pool, 2, sizeof(int));
177
182
    handled_requests = apr_array_make(test_pool, 2, sizeof(int));
178
183
 
179
184
    /* Set up a test context with a server */
180
 
    status = test_server_create(&tb, action_list, 2, 0, NULL, NULL, NULL,
 
185
    status = test_server_create(&tb,
 
186
                                message_list, 2,
 
187
                                action_list, 2, 0, NULL, NULL, NULL,
181
188
                                test_pool);
182
189
    CuAssertIntEquals(tc, APR_SUCCESS, status);
183
190
 
208
215
 
209
216
    apr_pool_create(&iter_pool, test_pool);
210
217
 
211
 
    while (!handler_ctx.done && !handler2_ctx.done)
 
218
    while (!handler_ctx.done || !handler2_ctx.done)
212
219
    {
213
220
        apr_pool_clear(iter_pool);
214
221
 
258
265
    apr_pool_t *iter_pool;
259
266
    apr_array_header_t *accepted_requests, *handled_requests, *sent_requests;
260
267
    int i;
 
268
 
 
269
    test_server_message_t message_list[] = {
 
270
        {CHUNCKED_REQUEST(1, "1")},
 
271
        {CHUNCKED_REQUEST(1, "2")},
 
272
        {CHUNCKED_REQUEST(1, "3")},
 
273
    };
 
274
 
261
275
    test_server_action_t action_list[] = {
262
 
        {SERVER_RECV,
263
 
         CHUNCKED_REQUEST(1, "1")
264
 
         CHUNCKED_REQUEST(1, "2")
265
 
         CHUNCKED_REQUEST(1, "3")
266
 
        },
267
 
        {SERVER_SEND,
268
 
         CHUNKED_EMPTY_RESPONSE
269
 
         CHUNKED_EMPTY_RESPONSE
270
 
         CHUNKED_EMPTY_RESPONSE
271
 
        }
 
276
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
277
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
278
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
272
279
    };
273
280
 
274
281
    accepted_requests = apr_array_make(test_pool, 3, sizeof(int));
276
283
    handled_requests = apr_array_make(test_pool, 3, sizeof(int));
277
284
 
278
285
    /* Set up a test context with a server */
279
 
    status = test_server_create(&tb, action_list, 2, 0, NULL, NULL, NULL,
 
286
    status = test_server_create(&tb,
 
287
                                message_list, 3,
 
288
                                action_list, 3, 0, NULL, NULL, NULL,
280
289
                                test_pool);
281
290
    CuAssertIntEquals(tc, APR_SUCCESS, status);
282
291
 
313
322
 
314
323
    apr_pool_create(&iter_pool, test_pool);
315
324
 
316
 
    while (!handler_ctx.done && !handler2_ctx.done && !handler3_ctx.done)
 
325
    while (!handler_ctx.done || !handler2_ctx.done || !handler3_ctx.done)
317
326
    {
318
327
        apr_pool_clear(iter_pool);
319
328
 
363
372
    handler_baton_t handler_ctx[NUM_REQUESTS];
364
373
    int done = FALSE, i;
365
374
 
 
375
    test_server_message_t message_list[] = {
 
376
        {CHUNCKED_REQUEST(1, "1")},
 
377
        {CHUNCKED_REQUEST(1, "2")},
 
378
        {CHUNCKED_REQUEST(1, "3")},
 
379
        {CHUNCKED_REQUEST(1, "4")},
 
380
        {CHUNCKED_REQUEST(1, "5")},
 
381
        {CHUNCKED_REQUEST(1, "6")},
 
382
        {CHUNCKED_REQUEST(1, "7")},
 
383
        {CHUNCKED_REQUEST(1, "8")},
 
384
        {CHUNCKED_REQUEST(1, "9")},
 
385
        {CHUNCKED_REQUEST(2, "10")}
 
386
        };
 
387
 
366
388
    test_server_action_t action_list[] = {
367
 
        {SERVER_RECV,
368
 
         CHUNCKED_REQUEST(1, "1")
369
 
         CHUNCKED_REQUEST(1, "2")
370
 
         CHUNCKED_REQUEST(1, "3")
371
 
         CHUNCKED_REQUEST(1, "4")
372
 
         CHUNCKED_REQUEST(1, "5")
373
 
         CHUNCKED_REQUEST(1, "6")
374
 
         CHUNCKED_REQUEST(1, "7")
375
 
         CHUNCKED_REQUEST(1, "8")
376
 
         CHUNCKED_REQUEST(1, "9")
377
 
         CHUNCKED_REQUEST(2, "10")
378
 
        },
379
 
        {SERVER_SEND,
380
 
         CHUNKED_EMPTY_RESPONSE
381
 
         CHUNKED_EMPTY_RESPONSE
382
 
         CHUNKED_EMPTY_RESPONSE
383
 
         "HTTP/1.1 200 OK" CRLF
384
 
         "Transfer-Encoding: chunked" CRLF
385
 
         "Connection: close" CRLF
386
 
         CRLF
387
 
         "0" CRLF
388
 
         CRLF
389
 
        },
390
 
        {SERVER_KILL_CONNECTION},
391
 
        {SERVER_SEND,
392
 
         CHUNKED_EMPTY_RESPONSE
393
 
         CHUNKED_EMPTY_RESPONSE
394
 
         CHUNKED_EMPTY_RESPONSE
395
 
         "HTTP/1.1 200 OK" CRLF
396
 
         "Transfer-Encoding: chunked" CRLF
397
 
         "Connection: close" CRLF
398
 
         CRLF
399
 
         "0" CRLF
400
 
         CRLF
401
 
        },
402
 
        {SERVER_KILL_CONNECTION},
403
 
        {SERVER_SEND,
404
 
         CHUNKED_EMPTY_RESPONSE
405
 
         CHUNKED_EMPTY_RESPONSE
406
 
        },
 
389
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
390
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
391
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
392
        {SERVER_RESPOND,
 
393
         "HTTP/1.1 200 OK" CRLF
 
394
         "Transfer-Encoding: chunked" CRLF
 
395
         "Connection: close" CRLF
 
396
         CRLF
 
397
         "0" CRLF
 
398
         CRLF
 
399
        },
 
400
        {SERVER_IGNORE_AND_KILL_CONNECTION},
 
401
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
402
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
403
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
404
        {SERVER_RESPOND,
 
405
         "HTTP/1.1 200 OK" CRLF
 
406
         "Transfer-Encoding: chunked" CRLF
 
407
         "Connection: close" CRLF
 
408
         CRLF
 
409
         "0" CRLF
 
410
         CRLF
 
411
        },
 
412
        {SERVER_IGNORE_AND_KILL_CONNECTION},
 
413
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
414
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
407
415
    };
408
416
 
409
417
    accepted_requests = apr_array_make(test_pool, NUM_REQUESTS, sizeof(int));
411
419
    handled_requests = apr_array_make(test_pool, NUM_REQUESTS, sizeof(int));
412
420
 
413
421
    /* Set up a test context with a server. */
414
 
    status = test_server_create(&tb, action_list, 6, 0, NULL, NULL, NULL,
 
422
    status = test_server_create(&tb,
 
423
                                message_list, 10,
 
424
                                action_list, 12,
 
425
                                0,
 
426
                                NULL, NULL, NULL,
415
427
                                test_pool);
416
428
    CuAssertIntEquals(tc, APR_SUCCESS, status);
417
429
 
484
496
    int i;
485
497
    int numrequests = 1;
486
498
    apr_sockaddr_t *proxy_address;
487
 
    test_server_action_t *action_list_server = NULL;
488
 
    test_server_action_t action_list_proxy[] = {
489
 
        {SERVER_RECV,
490
 
         "GET http://localhost:" SERV_PORT_STR " HTTP/1.1" CRLF\
 
499
 
 
500
    test_server_message_t message_list[] = {
 
501
        {"GET http://localhost:" SERV_PORT_STR " HTTP/1.1" CRLF\
 
502
         "Host: localhost:" SERV_PORT_STR CRLF\
491
503
         "Transfer-Encoding: chunked" CRLF\
492
 
         "Host: localhost" CRLF\
493
504
         CRLF\
494
505
         "1" CRLF\
495
506
         "1" CRLF\
496
507
         "0" CRLF\
497
 
         CRLF
498
 
        },
499
 
        {SERVER_SEND,
500
 
         CHUNKED_EMPTY_RESPONSE
501
 
        }
 
508
         CRLF}
 
509
    };
 
510
 
 
511
    test_server_action_t action_list_proxy[] = {
 
512
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
502
513
    };
503
514
 
504
515
    accepted_requests = apr_array_make(test_pool, numrequests, sizeof(int));
505
516
    sent_requests = apr_array_make(test_pool, numrequests, sizeof(int));
506
517
    handled_requests = apr_array_make(test_pool, numrequests, sizeof(int));
507
518
 
508
 
    /* Set up a test context with a server */
509
 
    status = test_server_create(&tb_server, action_list_server, 2, 0,
 
519
    /* Set up a test context with a server, no messages expected. */
 
520
    status = test_server_create(&tb_server,
 
521
                                NULL, 0,
 
522
                                NULL, 0, 0,
510
523
                                "http://localhost:" SERV_PORT_STR, NULL,
511
524
                                NULL, test_pool);
512
525
    CuAssertIntEquals(tc, APR_SUCCESS, status);
517
530
                                   test_pool);
518
531
    CuAssertIntEquals(tc, APR_SUCCESS, status);
519
532
 
520
 
    status = test_server_create(&tb_proxy, action_list_proxy, 2, 0,
 
533
    status = test_server_create(&tb_proxy,
 
534
                                message_list, 1,
 
535
                                action_list_proxy, 1, 0,
521
536
                                NULL, proxy_address, NULL,
522
537
                                test_pool);
523
538
 
645
660
    handler_baton_t handler_ctx[SEND_REQUESTS];
646
661
    int done = FALSE, i;
647
662
 
 
663
    test_server_message_t message_list[] = {
 
664
        {CHUNCKED_REQUEST(1, "1")},
 
665
        {CHUNCKED_REQUEST(1, "1")},
 
666
        {CHUNCKED_REQUEST(1, "1")},
 
667
        {CHUNCKED_REQUEST(1, "2")},
 
668
        {CHUNCKED_REQUEST(1, "3")},
 
669
        {CHUNCKED_REQUEST(1, "4")},
 
670
        {CHUNCKED_REQUEST(1, "5")},
 
671
    };
 
672
 
648
673
    test_server_action_t action_list[] = {
649
 
        {SERVER_RECV,
650
 
         CHUNCKED_REQUEST(1, "1")
651
 
        },
652
 
        {SERVER_SEND,
653
 
         CHUNKED_EMPTY_RESPONSE
654
 
        },
655
 
        {SERVER_RECV,
656
 
         CHUNCKED_REQUEST(1, "1")
657
 
        },
658
 
        {SERVER_SEND,
659
 
         CHUNKED_EMPTY_RESPONSE
660
 
        },
661
 
        {SERVER_RECV,
662
 
         CHUNCKED_REQUEST(1, "1")
663
 
        },
664
 
        {SERVER_SEND,
665
 
         CHUNKED_EMPTY_RESPONSE
666
 
        },
667
 
        {SERVER_RECV,
668
 
         CHUNCKED_REQUEST(1, "2")
669
 
        },
670
 
        {SERVER_SEND,
671
 
         CHUNKED_EMPTY_RESPONSE
672
 
        },
673
 
        {SERVER_RECV,
674
 
         CHUNCKED_REQUEST(1, "3")
675
 
        },
676
 
        {SERVER_SEND,
677
 
         CHUNKED_EMPTY_RESPONSE
678
 
        },
679
 
        {SERVER_RECV,
680
 
         CHUNCKED_REQUEST(1, "4")
681
 
        },
682
 
        {SERVER_SEND,
683
 
         CHUNKED_EMPTY_RESPONSE
684
 
        },
685
 
        {SERVER_RECV,
686
 
         CHUNCKED_REQUEST(1, "5")
687
 
        },
688
 
        {SERVER_SEND,
689
 
         CHUNKED_EMPTY_RESPONSE
690
 
        },
 
674
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
675
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
676
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
677
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
678
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
679
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
680
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
691
681
    };
692
682
 
693
683
    accepted_requests = apr_array_make(test_pool, RCVD_REQUESTS, sizeof(int));
695
685
    handled_requests = apr_array_make(test_pool, RCVD_REQUESTS, sizeof(int));
696
686
 
697
687
    /* Set up a test context with a server. */
698
 
    status = test_server_create(&tb, action_list, 14, 0, NULL, NULL, NULL,
 
688
    status = test_server_create(&tb,
 
689
                                message_list, 7,
 
690
                                action_list, 7, 0, NULL, NULL, NULL,
699
691
                                test_pool);
700
692
    CuAssertIntEquals(tc, APR_SUCCESS, status);
701
693
 
804
796
            }
805
797
            return APR_EOF;
806
798
        }
 
799
 
 
800
        if (APR_STATUS_IS_EAGAIN(status)) {
 
801
            return status;
 
802
        }
807
803
    }
808
804
 
809
805
    return APR_SUCCESS;
817
813
    handler_baton_t handler_ctx[SEND_REQUESTS];
818
814
    int done = FALSE, i;
819
815
 
 
816
    test_server_message_t message_list[] = {
 
817
        {CHUNCKED_REQUEST(1, "1")},
 
818
        {CHUNCKED_REQUEST(1, "1")},
 
819
        {CHUNCKED_REQUEST(1, "1")},
 
820
        {CHUNCKED_REQUEST(1, "2")},
 
821
        {CHUNCKED_REQUEST(1, "3")},
 
822
        {CHUNCKED_REQUEST(1, "4")},
 
823
        {CHUNCKED_REQUEST(1, "5")},
 
824
    };
 
825
 
820
826
    test_server_action_t action_list[] = {
821
 
        {SERVER_RECV,
822
 
         CHUNCKED_REQUEST(1, "1")
823
 
        },
824
 
        {SERVER_SEND,
825
 
         CHUNKED_EMPTY_RESPONSE
826
 
        },
827
 
        {SERVER_RECV,
828
 
         CHUNCKED_REQUEST(1, "1")
829
 
        },
830
 
        {SERVER_SEND,
831
 
         CHUNKED_EMPTY_RESPONSE
832
 
        },
833
 
        {SERVER_RECV,
834
 
         CHUNCKED_REQUEST(1, "1")
835
 
        },
836
 
        {SERVER_SEND,
837
 
         CHUNKED_EMPTY_RESPONSE
838
 
        },
839
 
        {SERVER_RECV,
840
 
         CHUNCKED_REQUEST(1, "2")
841
 
         CHUNCKED_REQUEST(1, "3")
842
 
         CHUNCKED_REQUEST(1, "4")
843
 
         CHUNCKED_REQUEST(1, "5")
844
 
        },
845
 
        {SERVER_SEND,
846
 
         CHUNKED_EMPTY_RESPONSE
847
 
         CHUNKED_EMPTY_RESPONSE
848
 
         CHUNKED_EMPTY_RESPONSE
849
 
         CHUNKED_EMPTY_RESPONSE
850
 
        },
 
827
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
828
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
829
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
830
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
831
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
832
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
833
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
851
834
    };
852
835
 
853
836
    accepted_requests = apr_array_make(test_pool, RCVD_REQUESTS, sizeof(int));
855
838
    handled_requests = apr_array_make(test_pool, RCVD_REQUESTS, sizeof(int));
856
839
 
857
840
    /* Set up a test context with a server. */
858
 
    status = test_server_create(&tb, action_list, 8, 0, NULL, NULL, NULL, 
 
841
    status = test_server_create(&tb,
 
842
                                message_list, 7,
 
843
                                action_list, 7, 0, NULL, NULL, NULL, 
859
844
                                test_pool);
860
845
    CuAssertIntEquals(tc, APR_SUCCESS, status);
861
846
 
933
918
    pb->written = written;
934
919
}
935
920
 
936
 
static serf_bucket_t* progress_conn_setup(apr_socket_t *skt,
 
921
static apr_status_t progress_conn_setup(apr_socket_t *skt,
 
922
                                          serf_bucket_t **input_bkt,
 
923
                                          serf_bucket_t **output_bkt,
937
924
                                          void *setup_baton,
938
925
                                          apr_pool_t *pool)
939
926
{
940
927
    test_baton_t *tb = setup_baton;
941
 
 
942
 
    return serf_context_bucket_socket_create(tb->context, skt, tb->bkt_alloc);
 
928
    *input_bkt = serf_context_bucket_socket_create(tb->context, skt, tb->bkt_alloc);
 
929
    return APR_SUCCESS;
943
930
}
944
931
 
945
932
static void test_serf_progress_callback(CuTest *tc)
951
938
    int done = FALSE, i;
952
939
    progress_baton_t *pb;
953
940
 
 
941
    test_server_message_t message_list[] = {
 
942
        {CHUNCKED_REQUEST(1, "1")},
 
943
        {CHUNCKED_REQUEST(1, "2")},
 
944
        {CHUNCKED_REQUEST(1, "3")},
 
945
        {CHUNCKED_REQUEST(1, "4")},
 
946
        {CHUNCKED_REQUEST(1, "5")},
 
947
    };
 
948
 
954
949
    test_server_action_t action_list[] = {
955
 
        {SERVER_RECV,
956
 
         CHUNCKED_REQUEST(1, "1")
957
 
         CHUNCKED_REQUEST(1, "2")
958
 
         CHUNCKED_REQUEST(1, "3")
959
 
         CHUNCKED_REQUEST(1, "4")
960
 
         CHUNCKED_REQUEST(1, "5")
961
 
        },
962
 
        {SERVER_SEND,
963
 
         CHUNKED_EMPTY_RESPONSE
964
 
         CHUNKED_RESPONSE(1, "2")
965
 
         CHUNKED_EMPTY_RESPONSE
966
 
         CHUNKED_EMPTY_RESPONSE
967
 
         CHUNKED_EMPTY_RESPONSE
968
 
        },
 
950
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
951
        {SERVER_RESPOND, CHUNKED_RESPONSE(1, "2")},
 
952
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
953
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
 
954
        {SERVER_RESPOND, CHUNKED_EMPTY_RESPONSE},
969
955
    };
970
956
 
971
957
    accepted_requests = apr_array_make(test_pool, NUM_REQUESTS, sizeof(int));
973
959
    handled_requests = apr_array_make(test_pool, NUM_REQUESTS, sizeof(int));
974
960
 
975
961
    /* Set up a test context with a server. */
976
 
    status = test_server_create(&tb, action_list, 2, 0, NULL, NULL, 
 
962
    status = test_server_create(&tb,
 
963
                                message_list, 5,
 
964
                                action_list, 5, 0, NULL, NULL, 
977
965
                                progress_conn_setup, test_pool);
978
966
    CuAssertIntEquals(tc, APR_SUCCESS, status);
979
967