Programmatic Refresh of a File System

Had to find a way to refresh the user's my computer windows to show drive mapping updates...
Here is my C# code:

/// <summary>
/// Changed for C# and to allow for network drive types.
/// </summary>
/// <param name="localDrive"></param>
public static void RefreshDrive(string localDrive)
{
    DEV_BROADCAST_VOLUME hdr = new DEV_BROADCAST_VOLUME();

    // collect and clean the passed LocalDrive param
    if (localDrive == null || localDrive.Length == 0)
        throw new System.Exception("Invalid 'localDrive' passed, 'localDrive' parameter cannot be 'empty'");
    char drive = localDrive[0];
    long result;

    hdr.dbcv_size = (uint)Marshal.SizeOf(hdr);
    hdr.dbcv_devicetype = (uint)DevType.DBT_DEVTYP_NET;
    hdr.dbcv_reserved = 0;
    hdr.dbcv_unitmask = (uint) 1 << (drive - 'A');
    hdr.dbcv_flags = (ushort)Dbtf.DBTF_NET;

    IntPtr hdrp = Marshal.AllocHGlobal(Marshal.SizeOf(hdr));
    Marshal.StructureToPtr(hdr, hdrp, true);
    MessageBroadcastRecipients recip = MessageBroadcastRecipients.BSM_ALLCOMPONENTS;

    result = BroadcastSystemMessage(MessageBroadcastFlags.BSF_NOHANG | MessageBroadcastFlags.BSF_POSTMESSAGE,
                           ref recip, WM_DEVICECHANGE, (IntPtr)DBT_DEVICEARRIVAL, hdrp);

    Marshal.FreeHGlobal(hdrp);
}

[DllImport("user32", SetLastError = true)]
private static extern int BroadcastSystemMessage(MessageBroadcastFlags flags, ref MessageBroadcastRecipients lpInfo, uint Msg, IntPtr wParam, IntPtr lParam);

const uint WM_DEVICECHANGE = 0x0219;
const uint DBT_DEVICEARRIVAL = 0x8000;

enum DevType : uint
{
    DBT_DEVTYP_OEM = 0,
    DBT_DEVTYP_DEVNODE = 1,
    DBT_DEVTYP_VOLUME = 2,
    DBT_DEVTYP_PORT = 3,
    DBT_DEVTYP_NET = 4,
}
enum Dbtf : uint
{
    DBTF_MEDIA = 0x0001,
    DBTF_NET = 0x0002,
}

[Flags]
enum MessageBroadcastFlags : uint
{
    BSF_QUERY = 0x00000001,
    BSF_IGNORECURRENTTASK = 0x00000002,
    BSF_FLUSHDISK = 0x00000004,
    BSF_NOHANG = 0x00000008,
    BSF_POSTMESSAGE = 0x00000010,
    BSF_FORCEIFHUNG = 0x00000020,
    BSF_NOTIMEOUTIFNOTHUNG = 0x00000040,
    BSF_ALLOWSFW = 0x00000080,
    BSF_SENDNOTIFYMESSAGE = 0x00000100,
    BSF_RETURNHDESK = 0x00000200,
    BSF_LUID = 0x00000400
}
[Flags]
enum MessageBroadcastRecipients : uint
{
    BSM_ALLCOMPONENTS = 0x00000000,
    BSM_VXDS = 0x00000001,
    BSM_NETDRIVER = 0x00000002,
    BSM_INSTALLABLEDRIVERS = 0x00000004,
    BSM_APPLICATIONS = 0x00000008,
    BSM_ALLDESKTOPS = 0x00000010
}

[StructLayout(LayoutKind.Sequential)]
public struct DEV_BROADCAST_VOLUME
{
    public uint dbcv_size;
    public uint dbcv_devicetype;
    public uint dbcv_reserved;
    public uint dbcv_unitmask;
    public ushort dbcv_flags;
}

If you're unmapping a drive and remapping it to a different location, you must call RefreshDrive after the unmap and then after the mapping. If you do just one, the drive map may disappear or still show the old name.

// Unmap the existing drive, if it exists.
UnmapDrive(Drive);
NetworkDrive.RefreshDrive(Drive);
Thread.Sleep(1000);
MapDrive(Drive, uncpath);
NetworkDrive.RefreshDrive(Drive);

Could the crash on some systems be because you're passing a pointer in LPARAM, and it'll only be valid in your own address space? It'll only crash if something is registered for those notifications and tries to use the pointer. There's some extra magic involved when the system sends them, to ensure it's valid for whatever is receiving it.

Another possibility is that you're POSTING the messages, but the pointer you're passing is to a stack variable that will be out of scope before some applications have processed the message. Making the structure variable static would help, but only if the pointer is actually valid to other processes anyway.

how can we write tcp related application in C/C++?
how can we specify SYN , FIN etc. flags of TCP header by using C/C++

Hi,

take a look to the 'SHChangeNotify' API with the 'SHCNE_MEDIAINSERTED' flag, it will refresh the window explorer content.
Isn't it what you needed? Big Grin | :-D

Ciao,
Cabbi

I'll try to use this method to refresh CDRW file system
after burning (without reloading CD), but unfortunately without any result.
The BroadcastSystemMessage procedure returns 1, but cd contents
does not refresh. I still need to reload CD to see a new content.
Please help me. I am using WINXP. Here is a text of my procedure (Delphi):

var hdr:TDevBroadcastVolume;
procedure refresh_cd(drive:string);
var
c:char;
r:integer;
begin
hdr.dbcv_size := sizeof(hdr);
hdr.dbcv_devicetype := DBT_DEVTYP_VOLUME;
hdr.dbcv_reserved := 0;

if length(drive)=0 then exit;
drive:=Uppercase(drive);
c:=drive[1];
hdr.dbcv_unitmask := 1 shl (ord(c)-ord('A'));
hdr.dbcv_flags := DBTF_MEDIA;

r := BroadcastSystemMessage(BSF_POSTMESSAGE or BSF_NOHANG,
0,
WM_DEVICECHANGE, DBT_DEVICEARRIVAL,
longint(@hdr));

form1.memo1.lines.add(format('return=%d',[r]));
end;

Your code assumes that the drive letter is upper case, but this is not enforced:

hdr.dbcv_unitmask = 1 << (cdrive-'A');

Maybe clients would consistently obtain correct results if you ensure the character is upper case before performing the bit shifting:

<br />
cdrive = (char)_totupper(cdrive));<br />
hdr.dbcv_unitmask = 1 << (cdrive - 'A');<br />

very good suggestion!
I've changed the article's code.

Matteo

visit http://www.genhome.org
------------------------------

The Windows bug I have for so long, because Windows don't refresh the CD content if you change it while you are in a modal dialog or the infamous SHBrowseForFolder !

My Lord ! So simple and elegant solution, thanks for the info !

Kochise

In Code we trust !

Thanks!!!
ehmmm... rate my article, please! Wink | ;-)

------------------------------
Matteo

visit http://www.genhome.org
------------------------------

seems risky broadcasting a message thate embeds a pointer to a local (ie stack ) structure.

martin l.

mmmmh...
how would you make it? suggestions?

Matteo

visit http://www.genhome.org
------------------------------

Hi,

Try putting the structure in a shared memory area adding this to your .cpp

<br />
#pragma comment(linker, "/SECTION:.SHARDATA,RWS")<br />
<br />
#pragma data_seg(".SHARDATA")<br />
DEV_BROADCAST_VOLUME hdr;<br />
#pragma data_seg()<br />

And then using the global variable.

Best regards,
Mauro H. Leggieri

I'm pretty sure the O/S takes care of this:

(From MSDN documentation)
The system only does marshalling for system messages (those in the range 0 to WM_USER). To send other messages (those above WM_USER) to another process, you must do custom marshalling.

To me that means that for any system message (e.g., WM_DEVICECHANGE) the O/S will take care of copying the data across process boundaries (marshalling).

Programmatic Refresh of a File System

Introduction

The function

License

Comments and Discussions