This would ever be looking at dysfunction.
Nick Sherry Not to enumerate are the computer shares on the computer, so it retrieves information about
each shared resource on his or her.
And here you can see the syntax.
The return type is net API status.
So that's Google's expertise.
And if you go to this website here, we have the values.
So the return type is actually integer.
So based on the return by, what you can do is you can compare the return type here.
So this.
So we can just compare the traditional values.
So let's first declare our input.
So this function is that we do not deliver.
So let's do the import.
So I am calling this return the integer and the function name.
And the first argument is bells are not a name, so it's not really computer name.
You can also parse that combatant name as well.
So it is Elon Musk here.
So it's similar to we can Marshall as well where character acting.
Marshall as unmanaged a not a p w sd.
So we can now just pass this as bringing it through.
We cannot be converted to this.
Right.
Got her pointer.
So copied username and the second parameter is level.
So here you can see the level level indicates that the enumeration you want to do on it, on the particular
computer, if you give the version zero, you get the return type of this pointer.
So I will get a normal address that is binding to the output structure.
So let's open this sharing for zero.
And here you can see there is only one member in this structure that is nickname so Pinder Unicode specifying
the shade name of the resource.
So it was simply that the name of the ship.
Okay.
Let's create the structure on that name.
So let's copy this.
And public after the structure.
So this is also going to be Marshall to this great character study.
So we can into martial arts, so we can just simply copy this.
So we are good to go.
Now, the second parameter for our function is the level.
So let's first, uh.
That is in beta.
So you don't see any negative here.
So we can say in beta level.
And the third type is they point out, so we can say better than the obvious point that we can just
specify with this endpoint.
And then action is put in front of my exponent by my event of the data we can.
We need to return.
So that's a.
132.
And then please read.
So the number of entries, the function hazard and the is total entries.
So we need to pass this as a reference.
Because the parameter we need to pass this as a reference so we get the value to our, uh, variable
so that order renders.
So sometimes you can get there, there are five entries you'll be able to only read or if your entries
because we do not have access to that some particular issue.
And then one is resume handle.
If you want to continue searching through the shares, you can use this handle.
So for now, let's consider, uh, null.
Okay.
This is our function.
Now we can call this and say let's in.
The result is equals to.
Net share in a month.
And the first.
Uh, paramedics bring them.
So let's go and find our horse name.
So I'm testing this on my machine.
I also tested on the Metro Network and it's working perfectly.
So the hostname of the computer and the level is zero because we have only the structural shade in form
zero and the next one is above there.
We need to create an interpreter that's above PTI recalls.
Do we want to?
Let's say first one, we can initiate digital zero, and after that we can serve both video.
So upon that function is the question.
We'll get the address into this year.
We can convert that to structure using module.
So the next one is a preferred one.
So I guess.
We can say just 100, I guess our 200.
And please read.
So this will be.
And Trace is equal to zero.
And also we can sit and read and order and Prince.
Rough entries.
Read the total entries.
We need to initiate this as well.
Okay.
The Russian is actually not border zero.
So they should do fine and return to the functions that seeds return babies narrow success.
So if you go to this summary, the value of the success, I think zero.
Yes, it's zero.
So we can also do that as well.
This is.
Cameras are.
Kevin.
We did not serve.
Okay?
So let's first normally run this.
Okay.
And here you can see the function.
And so it was really good that when you do expect this is a pointer, the point that is pointing to
the first element of this structure.
So we need to convert that pointer to the structure.
So what we can do is we can use Marshal Dot.
We are to structure, so we need to pass the pointer.
And the second one is so that it can calculate the size of the structure and it will take this information
and it will give you a proper structure for.
So both are common type of and this structure name some type of.
Sharon fled Europe.
And the return by these children for let's say is zero is equal to and we need to cash to this incoming
structure into this shared infrastructure so that our members will be actually protected in this.
Uh, the net net.
So that net will be accurate.
So what I can do is I can.
To print.
Yes.
Zero dot.
She did not know.
So if I go and run this and here you can see that are.
Our Soledad O'Brien,
daughter and prince.
And if you run this and here you can see there are 14 priests, but we have only one output because
our pointer is pointing to the fastest actual return.
If you add the length of this structure to this pointer, you will get the first element of the next
structure.
So what you can do is both are equal to four.
So y for the string is a pointer so that it occupies the four weights.
So that's.
Copy this.
Oh, that's.
Cut and paste here.
Now, if you go and.
If you go run this, I will get the next share so we can move over this one.
Fire in are easy questions.
Zero.
I.
I was then daughter in Paris.
I pressed press.
So let's go and run this.
Now you can see we got the same name because we are not incrementing it.
So let's go.
Earning driven.
This Musketeer press is equal to four.
Let's run this.
And here we can see all of the shared names.
But you don't need to calculate the size of this number.
You can say Marshal, not sizeof.
Just like in the previous videos, how we found the structure size.
And we print it to narrow where we can see the type of.
This shading -- up.
So let's run this one.
So do automatically target the structure a size and it will add to this pointer so that we get the first
member of the next structure.
So let's run this and we get the same one put.
So this is how you generate the shares using the net share function.
So this is a level zero.
We get the plane only the name of the ship.
So that's the level.
Bu this in this photo, we get much more information.
So that I bought the share.
So I also made this.
This is my get up.
Yes, yes.
If you go to this, we need to have examples.
Now you see this chair, you know, and these are the share types.
So the you get the number depending upon the type that you.
And also you can get the permissions currently in this part, actual part.
So let's go and get this shared in for two.
Secretary Cohen copied this and paste here and changed this to Zero Boo Boo.
And this is a big.
So far.
She had me copy all of this.
Our members.
Whatever the remark is this one saying that we can marshal this as a string.
So public string.
And the remaining of the next three members are will.
So based here.
But doing.
So I think our structure was completed, so we are good to go.
So you need to just change this level to two and put it in the pointer that is pointing to the area
of these shading for two structures.
So all you need to do is our name change to two.
Who?
And change everywhere from 0 to 2.
So let's give it a try.
We did not get character.
The result.
So one, two, three.
So there you go.
On to three.
So it's four, two, one, two, three.
Okay.
Oh, so this is the thing.
The number of bites.
What are the problem?
So we changed this for the max one and two to this one so that we got the output.
So we can also print other members as well.
They're screwed out.
And part.
Yes.
But.
Got and based below this nickname.
As to up.
Let's go and run this.
And here we can see the actual part of this.
And one thing I want is the tape of this one.
So it's the type.
The varies the type.
Okay.
We did not put this as public.
That's why I can't see it in the situation.
So this maximum this.
Now we can see this is the type.
So I have already read this one.
So you can see this order dictionary.
So let's copy this.
Now we need to check every value.
If the type is greater than or equal to this one, then we are going to print this.
So let's also copy this one.
Utopian impulses using systems or connections, not specialists, so that we can use our dictionaries.
So let's print here so we can just.
So that's one reason this there are areas.
And now we can see we got this type of gusher.
It's a special proboscis.
So this is how you read the sheriff using this next you function.
And also, I gather I want to give you guys a exercise.
So that is net user, you know, so this is all of these functions starting with this net or somewhat
similar scene.
You can see Netflix Reno I could give you are the users.
So the same syntax of these parameters and also there are levels I can see it's just uh.
The differences that I shared in full and four.
So you can see the same exact uh, uh, little copy of this, uh, function that showed it.
So, uh, give it a try.