← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to lib/orber/src/cdr_decode.erl

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/orber/src/cdr_decode.erl
2
2
%%
3
3
%% %CopyrightBegin%
4
4
%% 
5
 
%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
 
5
%% Copyright Ericsson AB 1997-2010. All Rights Reserved.
6
6
%% 
7
7
%% The contents of this file are subject to the Erlang Public License,
8
8
%% Version 1.1, (the "License"); you may not use this file except in
898
898
    {Seq, Rest2, Len2, NewC2} = dec_sequence_struct(Version, Rest1, N - 1,  TypeCodeList, Len1, ByteOrder, 
899
899
                                                    Buff, NewC, Name),
900
900
    {[list_to_tuple([Name |Struct]) | Seq], Rest2, Len2, NewC2}.
901
 
dec_sequence_union(_, Message, 0, _DiscrTC, _Default, _ElementList, Len, _ByteOrder, _Buff, C, _Name) ->
 
901
 
 
902
 
 
903
dec_sequence_union(_, Message, 0, _DiscrTC, _Default, _ElementList,
 
904
                   Len, _ByteOrder, _Buff, C, _Name) ->
902
905
    {[], Message, Len, C};
903
 
dec_sequence_union(Version, Message, N, DiscrTC, Default, ElementList, Len, ByteOrder, Buff, C, Name) ->
 
906
dec_sequence_union(Version, Message, N, DiscrTC, Default, ElementList,
 
907
                   Len, ByteOrder, Buff, C, Name) when is_list(ElementList) ->
904
908
 
905
909
    {Label, Rest1, Len1, NewC} = dec_type(DiscrTC, Version, Message, Len, ByteOrder, Buff, C),
906
910
    Result = dec_union(Version, stringify_enum(DiscrTC, Label), ElementList, Default, 
916
920
                                                   DiscrTC, Default, ElementList, 
917
921
                                                   Len2, ByteOrder, 
918
922
                                                   Buff, NewC3, Name),
919
 
    {[{Name, Label, Value} | Seq], Rest3, Len3, NewC4}.
 
923
    {[{Name, Label, Value} | Seq], Rest3, Len3, NewC4};
 
924
dec_sequence_union(Version, Message, N, _DiscrTC, _Default, Module,
 
925
                   Len, ByteOrder, Buff, C, Name) when is_atom(Module) ->
 
926
    case catch Module:tc() of
 
927
        {tk_union, _, _, DiscrTC, Default, ElementList} ->
 
928
            dec_sequence_union(Version, Message, N, DiscrTC, Default, ElementList,
 
929
                               Len, ByteOrder, Buff, C, Name);
 
930
        What ->
 
931
            orber:dbg("[~p] ~p:dec_sequence_union(~p). Union module doesn't exist or incorrect.", 
 
932
                      [?LINE, ?MODULE, What], ?DEBUG_LEVEL),
 
933
            corba:raise(#'MARSHAL'{completion_status=?COMPLETED_MAYBE})
 
934
    end.
 
935
   
 
936
 
920
937
 
921
938
%% A special case; when something is encapsulated (i.e. sent as octet-sequence)
922
939
%% we sometimes don not want the result to be converted to a list.
993
1010
%% Func: dec_union/9
994
1011
%%-----------------------------------------------------------------
995
1012
%% ## NEW IIOP 1.2 ##
996
 
dec_union(Version, ?SYSTEM_TYPE, Name, DiscrTC, Default, ElementList, Bytes, Len, ByteOrder, Buff, C) ->
 
1013
dec_union(Version, ?SYSTEM_TYPE, Name, DiscrTC, Default, ElementList, Bytes,
 
1014
          Len, ByteOrder, Buff, C) ->
997
1015
    {Label, Rest1, Len1, NewC} = dec_type(DiscrTC, Version, Bytes, Len, ByteOrder, Buff, C),
998
1016
    {Value, Rest2, Len2, NewC3} = dec_union(Version, Label, ElementList, Default, 
999
1017
                                            Rest1, Len1, ByteOrder, Buff, NewC),
1000
1018
    {{Name, Label, Value}, Rest2, Len2, NewC3};
1001
1019
 
1002
1020
 
1003
 
dec_union(Version, IFRId, _, DiscrTC, Default, ElementList, Bytes, Len, ByteOrder, Buff, C) ->
 
1021
dec_union(Version, IFRId, _, DiscrTC, Default, ElementList, Bytes, Len, 
 
1022
          ByteOrder, Buff, C) when is_list(ElementList) ->
1004
1023
    {Label, Rest1, Len1, NewC} = dec_type(DiscrTC, Version, Bytes, Len, ByteOrder, Buff, C),
1005
1024
    Result = dec_union(Version, stringify_enum(DiscrTC, Label), ElementList, Default, 
1006
1025
                                     Rest1, Len1, ByteOrder, Buff, NewC),
1012
1031
                    X
1013
1032
            end,
1014
1033
    Name = ifrid_to_name(IFRId, ?IFR_UnionDef),
1015
 
    {{Name, Label, Value}, Rest2, Len2, NewC3}.
 
1034
    {{Name, Label, Value}, Rest2, Len2, NewC3};
 
1035
dec_union(Version, IFRId, _, _DiscrTC, _Default, Module, Bytes, Len, 
 
1036
          ByteOrder, Buff, C) when is_atom(Module) ->
 
1037
    case catch Module:tc() of
 
1038
        {tk_union, _, Name, DiscrTC, Default, ElementList} ->
 
1039
            dec_union(Version, IFRId, Name, DiscrTC, Default, ElementList, Bytes, Len, 
 
1040
                      ByteOrder, Buff, C);
 
1041
        What ->
 
1042
            orber:dbg("[~p] ~p:dec_union(~p). Union module doesn't exist or incorrect.", 
 
1043
                      [?LINE, ?MODULE, What], ?DEBUG_LEVEL),
 
1044
            corba:raise(#'MARSHAL'{completion_status=?COMPLETED_MAYBE})
 
1045
    end.
 
1046
   
 
1047
    
1016
1048
 
1017
1049
dec_union(_, _, [], Default,  Message, Len, _, _Buff, C) when Default < 0 ->
1018
1050
    {undefined, Message, Len, C};
1047
1079
dec_struct1(Version, [{_ElemName, ElemType} | TypeCodeList], Message, Len, ByteOrder, Buff, C) ->
1048
1080
    {Element, Rest, Len1, NewC} = dec_type(ElemType, Version, Message, Len, ByteOrder, Buff, C),
1049
1081
    {Struct, Rest1, Len2, NewC2} = dec_struct1(Version, TypeCodeList, Rest, Len1, ByteOrder, Buff, NewC),
1050
 
    {[Element |Struct], Rest1, Len2, NewC2}.
 
1082
    {[Element |Struct], Rest1, Len2, NewC2};
 
1083
dec_struct1(Version, Module, Message, Len, ByteOrder, Buff, C) ->
 
1084
    case catch Module:tc() of
 
1085
        {tk_struct, _, _, TypeCodeList} ->
 
1086
            dec_struct1(Version, TypeCodeList, Message, Len, ByteOrder, Buff, C);
 
1087
        What ->
 
1088
            orber:dbg("[~p] ~p:dec_struct1(~p). Struct module doesn't exist or incorrect.", 
 
1089
                      [?LINE, ?MODULE, What], ?DEBUG_LEVEL),
 
1090
            corba:raise(#'MARSHAL'{completion_status=?COMPLETED_MAYBE})
 
1091
    end.
1051
1092
 
1052
1093
ifrid_to_name([], Type) ->
1053
1094
    orber:dbg("[~p] ~p:ifrid_to_name([], ~p). No Id supplied.", 
1232
1273
%%-----------------------------------------------------------------
1233
1274
dec_type_code(Version, Message, Len, ByteOrder, Buff, C) ->
1234
1275
    {TypeNo, Message1, Len1, NewC} = dec_type('tk_ulong', Version, Message, Len, ByteOrder, Buff, C),
1235
 
    dec_type_code(TypeNo, Version, Message1, Len1, ByteOrder, Buff, NewC).
 
1276
    TC = dec_type_code(TypeNo, Version, Message1, Len1, ByteOrder, Buff, NewC),
 
1277
    erase(orber_indirection),
 
1278
    TC.
1236
1279
 
1237
1280
%%-----------------------------------------------------------------
1238
1281
%% Func: dec_type_code/5
1441
1484
                                        {"name", {'tk_string', 0}}]},
1442
1485
                 Version, Rest1, 1, ByteOrder1, Buff, C+1+Ex),
1443
1486
    {{'tk_local_interface', RepId, Name}, Message1, Len1, NewC};
1444
 
dec_type_code(16#ffffffff, Version, Message, Len, ByteOrder, Buff, C) ->  %% placeholder
 
1487
dec_type_code(16#ffffffff, Version, Message, Len, ByteOrder, Buff, C) ->
1445
1488
    {Indirection, Message1, Len1, NewC} =
1446
1489
        dec_type('tk_long', Version, Message, Len, ByteOrder, Buff, C),
1447
1490
    Position = C+Indirection,
1448
 
    <<_:Position/binary, SubBuff/binary>> = Buff,
1449
 
    {TC, _, _, _} = dec_type_code(Version, SubBuff, Position, ByteOrder, Buff, Position),
1450
 
    {TC, Message1, Len1, NewC};
 
1491
    case put(orber_indirection, Position) of
 
1492
        Position ->
 
1493
%%          {{'none', Indirection}, Message1, Len1, NewC};
 
1494
            %% Recursive TypeCode. Break the loop.
 
1495
            orber:dbg("[~p] cdr_decode:dec_type_code(~p); Recursive TC not supported.", 
 
1496
                      [?LINE,Position], ?DEBUG_LEVEL),
 
1497
            corba:raise(#'MARSHAL'{completion_status=?COMPLETED_NO});
 
1498
        _ ->
 
1499
            <<_:Position/binary, SubBuff/binary>> = Buff,
 
1500
            {TC, _, _, _} = dec_type_code(Version, SubBuff, Position, ByteOrder, Buff, Position),
 
1501
            {TC, Message1, Len1, NewC}
 
1502
    end;
1451
1503
dec_type_code(Type, _, _, _, _, _, _) -> 
1452
1504
    orber:dbg("[~p] cdr_decode:dec_type_code(~p); No match.", 
1453
1505
                            [?LINE, Type], ?DEBUG_LEVEL),