none
BingMapsRESTToolkit. Getting Exception thrown at 0x76E79020 in w3wp.exe: 0xC0000005: Access violation reading location 0xFFFFFFFF. RRS feed

  • Question

  • I get the message

    when running in Visual Studio Debug mode.    I have tracked it down to this statement

      responseStream = await ServiceHelper.GetStreamAsync(new Uri(request.GetRequestUrl()));

    I have highlighted it in the code below.    I have also included the return values of the methods that are called before the error occurs.   In order they are

    Results at various checkpoints

    sb = {https://dev.virtualearth.net/REST/v1/Routes/Driving?&wp.0=41.5009,-81.70446&wp.1=41.41338,-81.63145&du=mi&ra=RouteSummariesOnly&dt=09/29/2017 13:14:25&maxSolns=1&key=AoZQNsoELFshbqYtcu167r0NtUvTEeBh-C9ysdwFuNLbCTDQuKwiw7XvAQvlPsux&clientApi=CSToolkit}

    tcs.Task = Id = 199, Status = WaitingForActivation, Method = "{null}", Result = "{Not yet computed}"

    A strange to note is this only occurs on the web application that is using Microsoft Azure Active Directory Tennant (Cloud - Single Organization) for Authentication.     Another website that does not have it works fine.  

    public static async Task<Response> GetResponseAsync(BaseRestRequest request)

            {
                Stream responseStream = null;
                if (request is ElevationRequest)
                {
                    var r = request as ElevationRequest;

                    if(r.Points != null && r.Points.Count > 50)
                    {
                        //Make a post request when there are more than 50 points as there is a risk of URL becoming too large for a GET request.
                        responseStream = await ServiceHelper.PostStringAsync(new Uri(r.GetPostRequestUrl()), r.GetPointsAsString(), null);
                    }
                    else
                    {
                        responseStream = await ServiceHelper.GetStreamAsync(new Uri(r.GetRequestUrl()));
                    }
                }
                else if (request is ImageryRequest)
                {
                    var r = request as ImageryRequest;

                    r.GetMetadata = true;

                    if (r.Pushpins != null && r.Pushpins.Count > 18)
                    {
                        //Make a post request when there are more than 18 pushpins as there is a risk of URL becoming too large for a GET request.
                        responseStream = await ServiceHelper.PostStringAsync(new Uri(r.GetPostRequestUrl()), r.GetPushpinsAsString(), null);
                    }
                    else
                    {
                        responseStream = await ServiceHelper.GetStreamAsync(new Uri(r.GetRequestUrl()));
                    }
                }
                else
                {
                    responseStream = await ServiceHelper.GetStreamAsync(new Uri(request.GetRequestUrl()));
                }

                if (responseStream != null)
                {
                    var ser = new DataContractJsonSerializer(typeof(Response));
                    var r = ser.ReadObject(responseStream) as Response;
                    responseStream.Dispose();
                    return r;
                }

                return null;
            }

    Results at various checkpoints

    sb = {https://dev.virtualearth.net/REST/v1/Routes/Driving?&wp.0=41.5009,-81.70446&wp.1=41.41338,-81.63145&du=mi&ra=RouteSummariesOnly&dt=09/29/2017 13:14:25&maxSolns=1&key=AoZQNsoELFshbqYtcu167r0NtUvTEeBh-C9ysdwFuNLbCTDQuKwiw7XvAQvlPsux&clientApi=CSToolkit}

    tcs.Task = Id = 199, Status = WaitingForActivation, Method = "{null}", Result = "{Not yet computed}"

    Please let me know if you need additonal informaiton.   This is driving me crazy!

    Friday, September 29, 2017 5:13 PM

Answers

  • I think I might know the issue. We are about to release an update as a new service is being released on Monday. After that I will investigate this issue and see if I can get to the bottom of it.

    [Blog] [twitter] [LinkedIn]

    Saturday, September 30, 2017 12:17 AM

All replies

  • Following some additional instructions for debugging I got

    Exception thrown at 0x7527C54F (KernelBase.dll) in w3wp.exe: 0x000006BA: The RPC server is unavailable. occurred

    below is the code from <g class="gr_ gr_94 gr-alert gr_spell gr_inline_cards gr_run_anim ContextualSpelling ins-del multiReplace" data-gr-id="94" id="94">registrykey</g>.cs.   The line <g class="gr_ gr_155 gr-alert gr_spell gr_inline_cards gr_run_anim ContextualSpelling ins-del multiReplace" data-gr-id="155" id="155">causeing</g> error has been underlined and bolded.

    Variable from line

    Win32Native.ERROR_MORE_DATA = 234

    r = 254795108

    hkey = {Microsoft.Win32.SafeHandles.SafeRegistryHandle}

    name = "Global"

    type Cannot obtain <g class="gr_ gr_218 gr-alert gr_gramm gr_inline_cards gr_run_anim Grammar only-ins doubleReplace replaceWithoutSep" data-gr-id="218" id="218">value</g> of the local variable or argument because it is not available at this instruction pointer, possibly because it has been optimized away.

    blob = {byte[65000]}

    sizeInput = 65000

       internal Object InternalGetValue(String name, Object defaultValue, bool doNotExpand, bool checkSecurity) {            
                if (checkSecurity) {       
                    // Name can be null!  It's the most common use of RegQueryValueEx
                    EnsureNotDisposed();
                }

                Object data = defaultValue;
                int type = 0;
                int datasize = 0;

                int ret = Win32Native.RegQueryValueEx(hkey, name, null, ref type, (byte[])null, ref datasize);

                if (ret != 0) {
                    if (IsPerfDataKey()) {
                        int size = 65000;
                        int sizeInput = size;
      
                        int r;
                        byte[] blob = new byte[size];
                        while (Win32Native.ERROR_MORE_DATA == (r = Win32Native.RegQueryValueEx(hkey, name, null, ref type, blob, ref sizeInput))) {
                            if (size == Int32.MaxValue) {
                                // ERROR_MORE_DATA was returned however we cannot increase the buffer size beyond Int32.MaxValue
                                Win32Error(r, name);
                            }
                            else if (size  > (Int32.MaxValue / 2)) {
                                // at this point in the loop "size * 2" would cause an overflow
                                size = Int32.MaxValue;
                            }
                            else {
                            size *= 2;
                            }
                            sizeInput = size;
                            blob = new byte[size];
                        }
                        if (r != 0)
                            Win32Error(r, name);
                        return blob;
                    }
                    else {
                        // For stuff like ERROR_FILE_NOT_FOUND, we want to return null (data).
                        // Some OS's returned ERROR_MORE_DATA even in success cases, so we 
                        // want to continue on through the function. 
                        if (ret != Win32Native.ERROR_MORE_DATA) 
                            return data;
                    }
                }

                if (datasize < 0) {
                    // unexpected code path
                    BCLDebug.Assert(false, "[InternalGetValue] RegQueryValue returned ERROR_SUCCESS but gave a negative datasize");
                    datasize = 0;
                }


                switch (type) {
                case Win32Native.REG_NONE:
                case Win32Native.REG_DWORD_BIG_ENDIAN:
                case Win32Native.REG_BINARY: {
                                     byte[] blob = new byte[datasize];
                                     ret = Win32Native.RegQueryValueEx(hkey, name, null, ref type, blob, ref datasize);
                                     data = blob;
                                 }
                                 break;
                case Win32Native.REG_QWORD:
                                 {    // also REG_QWORD_LITTLE_ENDIAN
                                     if (datasize > 8) {
                                         // prevent an AV in the edge case that datasize is larger than sizeof(long)
                                         goto case Win32Native.REG_BINARY;
                                     }
                                     long blob = 0;
                                     BCLDebug.Assert(datasize==8, "datasize==8");
                                     // Here, datasize must be 8 when calling this
                                     ret = Win32Native.RegQueryValueEx(hkey, name, null, ref type, ref blob, ref datasize);

                                     data = blob;
                                 }
                                 break;
                case Win32Native.REG_DWORD:
                                 {    // also REG_DWORD_LITTLE_ENDIAN
                                     if (datasize > 4) {
                                         // prevent an AV in the edge case that datasize is larger than sizeof(int)
                                         goto case Win32Native.REG_QWORD;
                                     }
                                     int blob = 0;
                                     BCLDebug.Assert(datasize==4, "datasize==4");
                                     // Here, datasize must be four when calling this
                                     ret = Win32Native.RegQueryValueEx(hkey, name, null, ref type, ref blob, ref datasize);

                                     data = blob;
                                 }
                                 break;

                case Win32Native.REG_SZ:
                                 {
                                     if (datasize % 2 == 1) {
                                         // handle the case where the registry contains an odd-byte length (corrupt data?)
                                         try {
                                             datasize = checked(datasize + 1);
                                         }
                                         catch (OverflowException e) {
                                             throw new IOException(Environment.GetResourceString("Arg_RegGetOverflowBug"), e);
                                         }
                                     }
                                     char[] blob = new char[datasize/2];

                                     ret = Win32Native.RegQueryValueEx(hkey, name, null, ref type, blob, ref datasize);
                                     if (blob.Length > 0 && blob[blob.Length - 1] == (char)0) {
                                         data = new String(blob, 0, blob.Length - 1);
                                     }
                                     else {
                                         // in the very unlikely case the data is missing null termination, 
                                         // pass in the whole char[] to prevent truncating a character
                                         data = new String(blob);
                                     }
                                 }
                                 break;

                case Win32Native.REG_EXPAND_SZ:
                                  {
                                     if (datasize % 2 == 1) {
                                         // handle the case where the registry contains an odd-byte length (corrupt data?)
                                         try {
                                             datasize = checked(datasize + 1);
                                         }
                                         catch (OverflowException e) {
                                             throw new IOException(Environment.GetResourceString("Arg_RegGetOverflowBug"), e);
                                         }
                                     }
                                     char[] blob = new char[datasize/2];

                                     ret = Win32Native.RegQueryValueEx(hkey, name, null, ref type, blob, ref datasize);

                                     if (blob.Length > 0 && blob[blob.Length - 1] == (char)0) {
                                         data = new String(blob, 0, blob.Length - 1);
                                     }
                                     else {
                                         // in the very unlikely case the data is missing null termination, 
                                         // pass in the whole char[] to prevent truncating a character
                                         data = new String(blob);
                                     }

                                     if (!doNotExpand)
                                        data = Environment.ExpandEnvironmentVariables((String)data);
                                 }
                                 break;
                case Win32Native.REG_MULTI_SZ:
                                 {
                                     if (datasize % 2 == 1) {
                                         // handle the case where the registry contains an odd-byte length (corrupt data?)
                                         try {
                                             datasize = checked(datasize + 1);
                                         }
                                         catch (OverflowException e) {
                                             throw new IOException(Environment.GetResourceString("Arg_RegGetOverflowBug"), e);
                                         }
                                     }
                                     char[] blob = new char[datasize/2];

                                     ret = Win32Native.RegQueryValueEx(hkey, name, null, ref type, blob, ref datasize);

                                     // make sure the string is null terminated before processing the data
                                     if (blob.Length > 0 && blob[blob.Length - 1] != (char)0) {
                                         try {
                                             char[] newBlob = new char[checked(blob.Length + 1)];
                                             for (int i = 0; i < blob.Length; i++) {
                                                 newBlob[i] = blob[i];
                                             }
                                             newBlob[newBlob.Length - 1] = (char)0;
                                             blob = newBlob;
                                         }
                                         catch (OverflowException e) {
                                             throw new IOException(Environment.GetResourceString("Arg_RegGetOverflowBug"), e);
                                         }
                                         blob[blob.Length - 1] = (char)0;
                                     }
                   

                                     IList<String> strings = new List<String>();
                                     int cur = 0;
                                     int len = blob.Length;

                                     while (ret == 0 && cur < len) {
                                         int nextNull = cur;
                                         while (nextNull < len && blob[nextNull] != (char)0) {
                                             nextNull++;
                                         }

                                         if (nextNull < len) {
                                             BCLDebug.Assert(blob[nextNull] == (char)0, "blob[nextNull] should be 0");
                                             if (nextNull-cur > 0) {
                                                 strings.Add(new String(blob, cur, nextNull-cur));
                                             }
                                             else {
                                                // we found an empty string.  But if we're at the end of the data, 
                                                // it's just the extra null terminator. 
                                                if (nextNull != len-1) 
                                                    strings.Add(String.Empty);
                                             }
                                         }
                                         else {
                                             strings.Add(new String(blob, cur, len-cur));
                                         }
                                         cur = nextNull+1;
                                     }
        
                                     data = new String[strings.Count];
                                     strings.CopyTo((String[])data, 0);
                                 }
                                 break;
                case Win32Native.REG_LINK:
                default:
                    break;
                }

                return data;
            }



    • Edited by Demtron Friday, September 29, 2017 9:30 PM
    Friday, September 29, 2017 9:20 PM
  • I think I might know the issue. We are about to release an update as a new service is being released on Monday. After that I will investigate this issue and see if I can get to the bottom of it.

    [Blog] [twitter] [LinkedIn]

    Saturday, September 30, 2017 12:17 AM