A map projection is simply a function that maps the points on the surface of the sphere to points in the plane.  The simplest possible projection is called the cylindrical projection.  You simply take the longitude and latitude and that becomes your X and Y coordinates.  It is called the cylindrical projection because geometrically, it is equivalent to wrapping the map around the globe to form a cylinder with the height of the cylinder being the height of the globe.  If you drew a line between the poles in the globe and then projected a ray at a normal from the line through the surface of the sphere and mapped that point to the point on the cylinder that the ray touched you’d get exactly the cylindrical projection.

Of course, there are infinitely many map projections.  All they need to do is map every point exactly once on the sphere to a point in the plane and you can draw a map.  But not all projections are created equal.  It turns out that there is no such thing as the perfect projection.  When you try to draw a large portion of the globe on a nice flat piece of paper there must be some distortion.  You can’t take a balloon, cut along one side, and lay it flat without stretching it in one way or another. And so instead a projection is chosen to have the features that you want with the resulting distortion being something you can live with.

One popular projection is the Mercator Projection. The Mercator projection preserves angles at the cost of distorting area. The Mercator projection also distorts the geodesic (the path that lies on the shortest distance between two points)   The Mercator projection is a sort of cylindrical projection, but the projection is stretched in the Y direction.  The map is stretched more  and more as you get closer to the poles.  This stretching gets so severe at the top and bottom of the map that the projection is largely useless north and south of 70 degrees.

Another interesting projection is the Scalar Projection.  This projection preserves area, at the cost of distorting angles.   A cylindrical projection distorts things more as they get towards the poles, just like the Mercator projection. In order to offset this distortion the map is contracted left-to-right more at the top and the bottom.  While the shapes may be distorted, the areas of the shapes are preserved.

Just so this post isn’t completely without a little code, I’ve coded up the Mercator and Sinusoidal projections in a little class below.

    // This code is provided AS-IS it implies no warrinties and conferres no rights
    class MapProjection
    {

        static public Double DegToRad(Double degrees)
        {
            return degrees * Math.PI / 180;
        }

        static public Double RadToDeg(Double radians)
        {
            return radians * 180 / Math.PI;
        }

        static public System.Windows.Point Mercator(Double baseLongitude, Double longitude, Double latitude)
        {
            System.Windows.Point point = new System.Windows.Point();
            point.X = longitude - baseLongitude;
            Double phi = DegToRad(latitude);
            point.Y = RadToDeg(Math.Log(Math.Tan(Math.PI / 4 + phi / 2)));
            //point.Y = RadToDeg((Math.Log((1 + Math.Sin(phi))/(1 - Math.Sin(phi)))/2);
            //point.Y = RadToDeg(Math.Log(Math.Tan(phi) + 1 / Math.Cos(phi)));

            return point;
        }

        static public System.Windows.Point Sinusodal(Double baseLongitude, Double longitude, Double latitude)
        {
            System.Windows.Point point = new System.Windows.Point();
            Double phi = DegToRad(latitude);
            point.X = RadToDeg((DegToRad(longitude) - DegToRad(baseLongitude)) * Math.Cos(phi));
            point.Y = latitude;

            return point;
        }

    }

In order to display the data we need massage the data some.  We need to shift and flip the map and we need to zoom in or out enough to be able to see it. It turns out that these are all what are known as linear transformations.  The math here is called linear algebra.  And each of these transformations can be accomplished by matrix multiplication.  Each transformation is represented by a matrix and you can multiply the vector by the transformation matrix and you get back the resulting vector.

Believe it or not, this is such a common operation in 2D drawing that there is already full support for this in C#.  You don’t really have to understand anything about matrices, how to build them, or how do to the multiplication.  You can build up your transformation matrix by using the  System.Media.Matrix class.  You can create a translation and scaling matrix simply by using the Translate and Scale methods. And if the data you need to transform is already and array of points, then you can apply the transformation by using the Transform method.  Imagine something like this:

// Do our transformations
Matrix scale = new Matrix();
scale.ScaleAt(4, -4, (minPoint.X + maxPoint.X) / 2, (minPoint.Y + maxPoint.Y) / 2);

minPoint = scale.Transform(minPoint);
maxPoint = scale.Transform(maxPoint);

Matrix translate = new Matrix();
translate.Translate(-minPoint.X, -maxPoint.Y);

minPoint = translate.Transform(minPoint);
maxPoint = translate.Transform(maxPoint);

for (Int32 index = 0; index < count; index++)
{
    record = (PolygonRecord)shapeFileFactory.Shapes[index];
    // We're going to display a projection, so we need to get the projected 
    // bounding box.  We'll do that by projecting the extreme points and 
    // using the result as the new bounding box. 
             
                
    // Now build an array of points that have been projected with the Mercator projection
    System.Windows.Point[] points = new System.Windows.Point[record.NumPoints];
    for (Int32 index2 = 0; index2 < record.NumPoints; index2++)
    {
        points[index2] = MapProjection.Sinusodal(0, record.Points[index2].X, record.Points[index2].Y);
    }

    // Do our transformations
    scale.Transform(points);
    translate.Transform(points);

}

      // Copyright Microsoft Corp. All rights reserved.
    // This code is provided AS-IS implies no warranties and confreres no rights
    class ShapeRecord
    {
        public Int32 RecordNumber { get; set; }
        public Int32 ContentLength { get; set; }
        public ShapeType Shape { get; set; }

        public static ShapeRecord FromBinaryReader(BinaryReader reader)
        {
            ShapeRecord Record = new ShapeRecord();

            Record.RecordNumber = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Record.ContentLength = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Record.Shape = (ShapeType)reader.ReadInt32();

            return Record;
        }
    }

So, we can safely read this data in for each record, and then based on the shape type, we can read the rest of the record.  In the case of the state boundary map that we are working with (statesp020.tar.gz.), all the shapes are polygons, and so we can limit our discussion to those. 

I’ve chosen to have a separate data structure for the bounding box and the point.  So we’ll need those structures first:

           // Copyright Microsoft Corp. All rights reserved.
    // This code is provided AS-IS implies no warranties and confreres no rights
    struct Point
    {
        public Double X { get; set; }
        public Double Y { get; set; }

        public Point(Double x, Double y)
            : this()
        {
            this.X = x;
            this.Y = y;
        }

        public Point(System.Windows.Point point)
            : this()
        {
            this.X = point.X;
            this.Y = point.Y;
        }

        public System.Windows.Point ToPoint()
        {
            return new System.Windows.Point(this.X, this.Y);
        }

        public static Point FromBinaryReader(BinaryReader reader)
        {
            Point point = new Point();

            point.X = reader.ReadDouble();
            point.Y = reader.ReadDouble();

            return point;
        }

        public static explicit operator Point(System.Windows.Point point)
        {
            Point myPoint = new Point(point);
            return myPoint;
        }
    }

    struct BoundingBox
    {
        public Double XMin { get; set; }
        public Double YMin { get; set; }
        public Double XMax { get; set; }
        public Double YMax { get; set; }

        public static BoundingBox FromBinaryReader(BinaryReader reader)
        {
            BoundingBox box = new BoundingBox();

            box.XMin = reader.ReadDouble();
            box.YMin = reader.ReadDouble();
            box.XMax = reader.ReadDouble();
            box.YMax = reader.ReadDouble();

            return box;
        }
    }

Now that we’ve got the structures to hold the polygon records, we just need to read them in.  Here’s a snippet that will do nicely:

    // Copyright Microsoft Corp. All rights reserved.
    // This code is provided AS-IS implies no warranties and confreres no rights
    shapes = new List<ShapeRecord>();
           
    try
    {
        while (true)
        {
            ShapeRecord record;
            try
            {
               record = ShapeRecord.FromBinaryReader(reader);
            }
            catch( System.IO.EndOfStreamException )
            {
                break;
            }
            switch (record.Shape)
            {
                case ShapeType.Polygon:
                {
                    PolygonRecord shape = PolygonRecord.FromBinaryReader(record, reader);
                    shapes.Add(shape);
                    break;
                }
                   
                default:
                     throw new InvalidDataException("Shape Type Not Recognized");
            }
        }
    }
    finally
    {
        if (file != null)
        {
            file.Close();
        }
    }

We’ve got the preliminaries out of the way now. We’ve got a nice map file to work with and tens of thousands of geospatial points.  From here we can have lots of fun.   In the future you can expect posts on displaying geospatial data, map projections, 2D transformations.  This is going to be a hoot!

I should also add here that while I am a professional developer, I’m certainly not a professional C# developer.  I live firmly in the world of C++, and not even modern C++.  My code has been described to me as “C with classes”.  But for jobs like this C# is a great too, and through little projects like this I’m trying to make myself more familiar with it.

The code follows fairly easily from the spec.  But there are a few interesting twists. One of them is the need to read bigendian integers.  With C++, this kind of conversion is very straightforward.  I can just do my typical type-unsafe cast and get at the raw memory and swap some bytes around. C# doesn’t really allow the same access.  Through a little searching I found the BitConverter class which lets me accomplish the same task.  It doesn’t let me do it in-place, but it works well enough. 

The C# code snippet below will do the job of reading the main file header of the shapefile.  In future posts I’ll look at reading the actual map data out of the file and perhaps we’ll even display it.

// Copyright Microsoft Corp. All rights reserved.
// This code is provided AS-IS implies no warranties and confers no rights

using System;
using System.IO;

namespace AlsShapeReader
{
    // Shape type codes
    enum ShapeType
    {
        NullShape = 0,
        Point = 1,
        PolyLine = 3,
        Polygon = 5,
        MultiPoint = 8,
        PointZ = 11,
        PolyLineZ = 13,
        PolygonZ = 15,
        MultiPointZ = 18,
        PointM = 21,
        PolyLineM = 23,
        PolygonM = 25,
        MultiPointM = 28,
        MultiPatch = 31
    }

    // A utility class to help read bigendian integers.
    static class BinaryUtilities
    {
        // Given two bytes, this routine will swap them.
        static void SwapBytes(ref Byte first, ref Byte second)
        {
            Byte temp;
            temp = first;
            first = second;
            second = temp;
            return;
        }

        // Reverses the byte order in a 32bit integer
        public static Int32 ReverseBytes(Int32 value)
        {
            Int32 returnValue;
            byte[] bytes = BitConverter.GetBytes(value);

            SwapBytes(ref bytes[0], ref bytes[3]);
            SwapBytes(ref bytes[1], ref bytes[2]);

            returnValue = BitConverter.ToInt32(bytes, 0);

            return returnValue;
        }
    }

    // Class to hold the data from the main file header of a shape file
    class MainFileHeader
    {
        public Int32 FileCode { get; set; }
        public Int32 Unused1 { get; set; }
        public Int32 Unused2 { get; set; }
        public Int32 Unused3 { get; set; }
        public Int32 Unused4 { get; set; }
        public Int32 Unused5 { get; set; }
        public Int32 FileLength { get; set; }
        public Int32 Version { get; set; }
        public ShapeType Shape { get; set; }
        public Double XMin { get; set; }
        public Double YMin { get; set; }
        public Double XMax { get; set; }
        public Double YMax { get; set; }
        public Double ZMin { get; set; }
        public Double ZMax { get; set; }
        public Double MMin { get; set; }
        public Double MMax { get; set; }

        // Utility routine to populate the data from a Binary Reader
        public static MainFileHeader FromBinaryReader(BinaryReader reader)
        {
            MainFileHeader Header = new MainFileHeader();

            Header.FileCode = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Header.Unused1 = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Header.Unused2 = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Header.Unused3 = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Header.Unused4 = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Header.Unused5 = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Header.FileLength = BinaryUtilities.ReverseBytes(reader.ReadInt32());
            Header.Version = reader.ReadInt32();
            Header.Shape = (ShapeType)reader.ReadInt32();
            Header.XMin = reader.ReadDouble();
            Header.YMin = reader.ReadDouble();
            Header.XMax = reader.ReadDouble();
            Header.YMax = reader.ReadDouble();
            Header.ZMin = reader.ReadDouble();
            Header.ZMax = reader.ReadDouble();
            Header.MMin = reader.ReadDouble();
            Header.MMax = reader.ReadDouble();

            return Header;
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            BinaryReader reader;
            FileStream file;
            MainFileHeader header;

            String fileName = @"C:\Users\alanlu\Downloads\New Folder\statesp020.shp";
            file = File.Open(fileName, FileMode.Open);
            reader = new BinaryReader(file);
            header = MainFileHeader.FromBinaryReader(reader);
        }
    }
}

One of the things that I’ve discovered is that the government is a huge source of free location data.   And much of that location data is available in binary form for free.  On of my recent finds is https://nationalatlas.gov.  There are dozens of map layers available and they are all available in binary form.  For example here is the location to download the digital map of the us states.  I’ve written a simple viewer for this data that might make for some interesting blog posts.  So, stay tuned and over the course of time I’ll share what I found and some of the toys that I’ve written

There are a couple of ways that you can get access to data on the network in Windows.  Two of the most popular are “mapping a network drive” and “UNC Shares”.  WMC only supports UNC Shares.  These are share names of the form \\alanlu02\media for example.  If you go into the WMC UI and attempt to share out content on a network drive then WMC will attempt to figure out the equivalent UNC path and share that instead.

The big problem that comes in to play with network shares are all permission related. You have to grant the right permissions. The easiest case is for a Windows XP box that is not domain joined. In this case, you must set the file and share permissions to be READ for the NETWORK account.  That’s great, but what about files that are on a version of Windows Server?  I got the full scoop from Mukul, who worked with me on WMC.  Among other things he wrote the file scanner and added the network share support.  Here is what he shared:

If:

1. Your media is in a share on a W2K computer in a workgroup (for example: \\W2KServerName\FooShare) and
2. You want to access this media on your devices using WMCv2.0 running on a WinXP machine in workgroup

Continue reading below about the permissions requirements for W2K machine:

1. ADD READ permission for "NETWORK" account in the W2K share permissions

   For example: On W2K machine, If you are sharing C:\Foo as "FooShare", then open properties of C:\Foo, go to "Sharing" tab on properties windows. It will show you the information about "FooShare". Click "Permissions" button there (which is used to set permissions of this share) and add READ permission for NETWORK account

2. ADD READ permission for "NETWORK" account in the security permissions of underlying folder (folder that is being shared). 

   For example: On W2K machine, if you are sharing C:\Foo as "FooShare", then add READ permission for NETWORK account in the Properties->”Security” of folder C:\Foo.

3. Enable guest account on your W2K machine (it is disabled by default on W2K machines). See this link for information on it (https://support.microsoft.com/default.aspx?scid=kb;en-us;258938)

   In general, WMCv2.0 should be able to access contents on W2K share after the steps given above.

4. If it is still not working, try one more step. Some W2K machines have ANONYMOUS sessions explicitly disabled on them. To allow anonymous access on these shares, see this link: https://support.microsoft.com/default.aspx?scid=kb;en-us;289655

 There are three common reasons why WMC won’t expose a file.

1.  The file format isn’t supported
2. The file permissions don’t allow WMC to read the file
3. The file can’t be parsed by WMC (file is corrupt or has unrecognized content)

Let’s take these in order.

WMC supports files with the following extensions (the official list is here https://www.microsoft.com/windows/windowsmedia/devices/wmconnect/faq.aspx#5_1).

 Audio

• Windows Media Audio (.wma)
• Advanced Systems Format (.asf)
• MP3 (.mp3)
• WAV (.wav)

Video

• Windows Media Video (.wmv)
• Microsoft Recorded TV Show (.dvr-ms)
• Audio Video Interleaved (.avi)
• MPEG-1 (.mpeg, .mpg)
• MPEG-2 (.mp2, .mpeg, .mpg)

Picture

• Bitmap (.bmp)
• Graphics Interchange Format (.gif)
• Joint Photographic Experts Group (.jpeg, .jpg)
• Portable Network Graphics (.png)
• Tagged Image File Format (.tif, .tiff)

Playlists

• Windows Media Playlist (.wpl)
• MP3 Playlist (.m3u)

If your media file isn’t in one of the above formats, then you’ll need to convert it to one of the above formats if you’d like to use WMC to play it back.  The two file formats that I hear about most often that aren’t supported are .MP4 and whatever the iTunes format is (I honestly can’t remember what the extension is).

The next most common problem is file permissions.  In order to share a local file the file must have read permissions granted to NETWORK SERVICE.  You can check permissions on a particular file using the cacls.exe program from the command line or you can do it in explorer.  Detailed instructions on how to fix file permission errors from explorer are found here https://www.microsoft.com/windows/windowsmedia/devices/wmconnect/faq.aspx#4_5.

The last problem that is commonly encountered are file parsing problems.  For some reason WMC hits an error when trying to read the file.  If WMC can’t parse the file it doesn’t share the file.  There are a couple of ways to attach this problem.  First, if the file doesn’t play in windows media player it probably won’t play in WMC either.  Try that first.  If that works then it is still possible that the file can’t be parsed by WMC.  You should check the file-scanning log that is usually found at this path:

C:\Documents and Settings\NetworkService\Local Settings\Application Data\Microsoft\Windows Media Connect 2\FileScanLogFile.txt

Sometimes more detailed error information can be found.  This file can be quite large so it may take some time to find the particular file that you are interested in.

When the DMR wants to find WMC (or vice versa) it sends out an SSDP MSEARCH request.  When a UPnP device that matches the parameters of the search hears the broadcast it responds with its own announcement.  Alternately, WMC sends out an announcement every five minutes or so to advertise its presence. 

Let’s imagine what could go wrong.  First, the MSEARCH may not be getting to WMC.  This could be caused by bad cables, bad routers, or firewalls.  I’ve already covered how to fix all of those, because they would also block WMC from seeing the DMR.  If you’ve got Internet connectivity for your PC and your DMR you can eliminate cables as the cause.  Next, I’d eliminate the router by connecting directly. If that still didn’t work, I’d start disabling the firewalls. That isn’t really a problem at this point, because you aren’t connected to the internet if you aren’t connected to your router, right?  Don’t ever disable your firewall while connected to the internet.

There is another scenario that should be considered when WMC can see your DMR, but not the other way around.  It is actually the UPnP Content Directory Service (CDS) that the DMR goes looking for. WMC won’t advertise a CDS if there are no files shared.  Basically, WMC won’t advertise an empty library.  So, what could cause an empty library?  Two things come to mind. First, if you never completed the first-run wizard then there are no folders shared. No folders shared, means no files shared. No files shared means no CDS.  Even though WMC can find the DMR, the DMR doesn’t have a CDS to find.  Second, you may not have permission to read the files that you’ve shared.  No access to the files means no files shared.  And no Files Shared means no CDS.  I’ve seen this happen most with domain joined PCs (see my last article).  For one of the reasons discussed in that article WMC can’t validate that the user has access to the files, so it doesn’t share them.  The result is again no CDS for the DMR to find.

So, when you start up WMC for the first time, do it from a local account that has administrator privileges and complete the first run wizard even if you can’t find the DMR.  You need to do that to be sure that there is a CDS to find later.  The rest of the troubleshooting steps are the same as in the case where WMC can’t find the DMR.

For those of you with a domain controller at home, make sure the computer running WMC has been added to the Windows Authorization Access group in Active Directory.  Also, you have to either disable IPSEC on your domain or configure the WMC computer as a boundary machine so that it can communicate with non-IPSEC devices. 

For those of you who have a home computer joined to a corporate domain you have less control over your situation.  What I’ve done in this situation is to log in with the local administrator account (a non-domain account) and do my folder sharing from there. 

There are two basic problems here that have to be overcome.  The first is simple connectivity.  IPSEC encrypts part of the packets.  There isn’t any shipping Digital Media Receiver (DMR) that I know of that support IPSEC.  So, if you want basic connectivity with a DMR you are going to have to communicate with it without using IPSEC.

The second issue that has to be overcome is basic file permissions.  WMC is a service that runs under the NETWORK SERVICE account.  In order to share the files over the network it must have access to them. At service startup it walks through its list of shares and checks to see if the person who shared the files has access.  In the case of the domain joined PC that person is a domain user.  Therefore it must interact with the domain to determine access.  The NETWORK SERVICE account won’t have access to the security information of the user who shared the folder if the machine isn’t added to the Windows Authorization Access Group in Active Directory.  Since the service can’t validate that the user who granted the shares has permission on the files it won’t expose a server. This same situation arises when a Domain Joined PC is disconnected from the domain (as when you bring home a corporate laptop).  The NETWORK SERVICE account can’t communicate with the domain to validate file permissions and therefore it won’t expose a server. 

Did the script give an error?  This could be caused by the UPnP Services not being started.  Go look at this post: https://blogs.msdn.com/alan_ludwig/archive/2006/01/20/515333.aspx

Does basic internet connectivity work?  Do you have a router?  Check out this post, and make sure you are testing with a “direct” and “wired” connection: https://blogs.msdn.com/alan_ludwig/archive/2006/01/18/WMCOverview.aspx

If it still doesn’t see the device the most likely cause is some kind of firewall.  For basic discovery, the ports that must be opened in the PC firewall have already been discussed here: https://blogs.msdn.com/alan_ludwig/archive/2006/01/23/516232.aspx.  But, since firewalls are the most likely problem in if you’ve gotten this far then this is a good place to review all of ports and why they need to be opened.  Here’s the full list of ports that are used by WMC: 1900 UDP,2869 TCP,10243 TCP, 10280 – 10284 UDP.

In previous posts, I’ve already covered what is done with 1900 UDP, and 2869 TCP.  Port 1900 is used for SSDP discovery.  This is where the multicast device announcements come in.  I’ve also already covered what happens on port 2869 TCP.  This is the main port for all UPnP traffic.  UPnP is basically HTML and SOAP, so essentially there is a web-server at 2869 TCP.

Port 10243 TCP is used by WMC to actually stream the media to the PC.  Basically, there is a web server on this port.  The Digital Media Receiver (DMR) uses UPnP on port 2869 to get a list of the music, video, or photos that are available.  When it is ready to play music (for example) it gets the URL of the song from UPnP and then requests it.  The port in that URL is port 10243.  The web server then streams the music to the DMR on that port.

Ports 10280 – 10284 UDP are used by Windows Media Digital Rights Management for Network Devices (WMDRM-ND) as part of the device registration process.  I’m not going to go into great detail about what they are used for since the internals of DRM are beyond the scope of this post.  But if you’d like to play-back protected music, then these ports need to be open.  Having these ports block will not interfere with discovery or even keep unprotected content from playing back. 

WMC was tested and works perfectly well with the Windows firewall. If you don’t have a 3rd party firewall, then there is no reason to go in and adjust or turn off the windows firewall.  The most you should need to do to get the windows firewall working correctly with WMC is to go into the advanced tab on the windows firewall and choose “Restore Defaults”.  After that go into the WMC User Interface (UI) and choose “Reset” under the firewall section.  If you’d like to make especially sure that it isn’t the windows firewall then you can disable it.  But, I would only do that if you are physically disconnected from the internet.  If you ever review your firewall logs you’ll see that when you are connected to the internet (especially an always-on broadband connection) you are attacked every few minutes at most. Don’t disable your firewall while you are connected to the internet.

For 3rd party firewalls you should seek help from your firewall provider.  From the newsgroups and web-forums that I visit I’ve heard a whole range of things that people had to do to get WMC working with 3rd party firewalls. I’ve heard everything from “I just opened the ports” to “I had to completely uninstall the firewall”.  Again, my advice is always the same.  If you are using a 3rd party firewall and you disable or remove it to troubleshoot WMC, don’t do that while you are connected to the internet. 

I highly recommend using firewall software.  It is critically important to have that protection.  Personally, I use the built-in windows firewall. I don’t use a 3rd party firewall on any of my computers.  My primary source of security is the firewall in my hardware router.  As a second layer of security I use the built-in Windows Firewall.  I’ve run all kinds of security scans available from reputable sources and when running in this configuration they all give me passing marks. As part of my security practices I run real-time virus detection software as well as a full scan every night (automatically scheduled while I sleep).  I also have ad ware and spyware protection. The only downside (in theory) to not running a 3rd party firewall on my computer is that I don’t control or block outgoing connections.  With the two incoming firewalls, and the ad ware and virus protection packages I don’t feel like this is a fatal security flaw.  Most folks don’t have the expertise to actually make good decisions about the validity of a particular outgoing connection so in the end I don’t think it helps much anyway.  Mostly it is just annoying to keep the list of “authorized applications” up to date and to deal with the constant pop-ups from the 3rd party firewall to authorize a particular connection or application.

That’s my whole rant on firewalls and how to troubleshoot them.  But, that isn’t the whole list of things that could be causing problems.  If your PC is a member of a domain there  a few other issues that you could run into.  I’ll cover those next time.