473,854 Members | 1,818 Online
Bytes | Software Development & Data Engineering Community
+ Post

Home Posts Topics Members FAQ

realloc(): invalid next size

Greetings all,

I have a program that used the realloc() function to change the
allocated size of a buffer, the program works with some arguments, but
with some other arguments, it will show me the error message like:

*** glibc detected *** realloc(): invalid next size: 0x0804c3a8 ***

and then I inserted a perror("realloc ") to see what happend, it says that:

realloc: Illegal seek
the realloc() is in a loop:

for (m = 0; m < len; m++) {
if (isspace(data[m]) || ispunct(data[m]) ||
isdigit(data[m]))
printf("%c", data[m]);
else {
p = min(strcspn(&da ta[m], " "),
strcspn(&data[m], "\t"),
strcspn(&data[m], "\r"),
strcspn(&data[m], "\n"));
key = realloc(key, p);
strncpy(key, &data[m], p);
key[p] = '\0';
trans(key, p);
m = m + p - 1;
}
}

and the "key" is already malloced before the loop:

char *key = malloc(1);

Any suggestion could be helpful, thx very much!

Deephay
Apr 11 '06
27 31503
Chris Torek wrote:
Michael Wojcik wrote:
The result of realloc should always be stored in a temporary
variable and should be checked for null. If it is null, remember
to free the old value ...


In article <sl************ *******@ID-203069.user.ind ividual.net>
Pedro Graca <he****@hotpop. com> wrote:
Uh? Doesn't realloc(), when it doesn't fail, call free() all by itself
if there's a need for that?


No!

[snip comprehensive answer]

Thank you very much for the comprehensive answer.

--
If you're posting through Google read <http://cfaj.freeshell. org/google>
Apr 11 '06 #11

"Chris Torek" <no****@torek.n et> wrote in message
news:e1******** @news2.newsguy. com...
Michael Wojcik wrote:
The result of realloc should always be stored in a temporary
variable and should be checked for null. If it is null, remember
to free the old value ...

In article <sl************ *******@ID-203069.user.ind ividual.net>
Pedro Graca <he****@hotpop. com> wrote:
Uh? Doesn't realloc(), when it doesn't fail, call free() all by itself
if there's a need for that?


No!

With a few exceptions (noted below), realloc() is essentially an
optimized version of the following:

void *realloc(void *old, size_t newsize) {
size_t oldsize = __some_sort_of_ magic_done_here (old);
void *new;

new = malloc(newsize) ;
if (new != NULL) {
memcpy(new, old, oldsize < newsize ? oldsize : newsize);
free(old);
}
return new;
}


Hmm, no NULL check for old?

<snip> (Seriously: C89 specifically said that realloc(NULL,n) was equivalent
to malloc(n), and malloc(0) *could* be equivalent to malloc(1); it
then also said that realloc(p,0) was equivalent to free(p); so what
then is realloc(NULL,0) -- is it like malloc(0) and hence like
malloc(1), or is it just free(NULL)?)


If your question wasn't rhetorical, this realloc probably answers your
question. It has undefined behavior since it doesn't determine the 'magic
mystery size' of s1...

void *my_realloc (void *s1, size_t size)
{
void *s2=NULL;

if (size!=0||s1==N ULL)
s2 = malloc(size);
else
free(s1);
if (s1!=NULL)
memcpy(s2, s1, size);
return(s2);
}
Rod Pemberton
Apr 12 '06 #12

Michael Wojcik wrote:
In article <e1***********@ news3.infoave.n et>, Deephay <tu*****@gmail. com> writes:

I have a program that used the realloc() function to change the
allocated size of a buffer, the program works with some arguments, but
with some other arguments, it will show me the error message like:

*** glibc detected *** realloc(): invalid next size: 0x0804c3a8 ***
glibc is off-topic for comp.lang.c, but this is glibc telling you
that you have invoked Undefined Behavior. Probably you have
corrupted glibc's housekeeping data by performing an illegal
operation on an object with dynamic storage duration, such as writing
past the end of an allocated area.
and then I inserted a perror("realloc ") to see what happend, it says that:


What will happen is that you will get a meaningless message written
to stderr. realloc does not set errno, so perror will report whatever
happens to have already been in errno.
the realloc() is in a loop:

for (m = 0; m < len; m++) {
if (isspace(data[m]) || ispunct(data[m]) ||
isdigit(data[m]))
printf("%c", data[m]);
else {
p = min(strcspn(&da ta[m], " "),
strcspn(&data[m], "\t"),
strcspn(&data[m], "\r"),
strcspn(&data[m], "\n"));
key = realloc(key, p);


Wrong for two reasons. You failed to check whether realloc
succeeded, and if it failed, you just lost the old value of "key"
and so introduced a memory leak.

The result of realloc should always be stored in a temporary
variable and should be checked for null. If it is null, remember
to free the old value:

char *newkey;
newkey = realloc(key, p);
if (! newkey)
{
free(key);
[perform error handling]
}
key = newkey;
strncpy(key, &data[m], p);
key[p] = '\0';


You just wrote past the end of the allocated area. Since key is an
area of p bytes, valid indices are 0 through p-1, inclusive.
and the "key" is already malloced before the loop:

char *key = malloc(1);


Did you check to see whether malloc succeeded?
Any suggestion could be helpful, thx very much!


Read the comp.lang.c FAQ (http://www.c-faq.com is one source). Get a
copy of the C standard. C makes little effort to protect you from
yourself; you will only produce reliable, correct C code by learning
the language and its pitfalls.


thx a lot for those suggestions!

--
Michael Wojcik mi************@ microfocus.com

The lecturer was detailing a proof on the blackboard. He started to say,
"From the above it is obvious that ...". Then he stepped back and thought
deeply for a while. Then he left the room. We waited. Five minutes
later he returned smiling and said, "Yes, it is obvious", and continued
to outline the proof. -- John O'Gorman


Apr 12 '06 #13

Richard Bos wrote:
Deephay <tu*****@gmail. com> wrote:
Richard Bos wrote:
Deephay <tu*****@gmail. com> wrote: p = min(strcspn(&da ta[m], " "),
> strcspn(&data[m], "\t"),
> strcspn(&data[m], "\r"),
> strcspn(&data[m], "\n"));

Why not simply use strcspn(&data[m], " \t\r\n")?

I have to get the index where the first "space" locates.


That one call does the same thing as those four calls plus a properly
written min() function.
> key = realloc(key, p);
> strncpy(key, &data[m], p);
> key[p] = '\0';
> trans(key, p);
> m = m + p - 1; and the "key" is already malloced before the loop:
>
> char *key = malloc(1);

Hard to say what the real problem is without any object or function
definitions, but two questions spring to mind:
- does this occur immediately, or after a few iterations;
- what actually is the value of p (and if this code isn't complete, of
key) at the point where it produces the error?

the error occurred after a few iterations, the first realloc will always
success.
the p is always larger than 0, I have tested. Actually it will be a
quite normal value where the error produced, say, 7, 8, or whatever...

What I think now is that it might be a bug of glibc...


That is the last thing I would consider.
I searched with google and found some unsolved problem like the one I have.


You can find a great many confused bug-writers on the 'web, yes, many of
them blaming their tools for their own mistakes.
What I did now is, declare a key[50] static, this works fine.


It probably works around a bug - using strncpy() without thorough
understanding is asking for one, btw - and leaves a time bomb in your
code. What happens if you encounter a token larger than 50 characters?
Worse, what if you encounter one of _precisely_ 50 characters?
I still want to make sure what the problem is, though.


Without more code which demonstrates the problem precisely, it is
impossible to be certain. If the above is your exact code, you have
several off-by-one errors; then again, if the above is your exact code,
it doesn't compile, because there is a lot missing.

If you want more help, what you should do now is the following:
- make a copy of your existing code;
- whittle it down to the smallest _compilable_ program which still
exhibits the same problem;
- post _exactly_ that code. Paste, do not retype it into your post,
otherwise you'll make typos.

Richard


thx for the suggestions, Richard, I'll try to exam the code again.

Apr 12 '06 #14
Rod Pemberton wrote:
"Chris Torek" <no****@torek.n et> wrote in message
news:e1******** @news2.newsguy. com...
(Seriously: C89 specifically said that realloc(NULL,n) was equivalent
to malloc(n), and malloc(0) *could* be equivalent to malloc(1); it
then also said that realloc(p,0) was equivalent to free(p); so what
then is realloc(NULL,0) -- is it like malloc(0) and hence like
malloc(1), or is it just free(NULL)?)


If your question wasn't rhetorical, this realloc probably answers your
question. It has undefined behavior since it doesn't determine the 'magic
mystery size' of s1...

void *my_realloc (void *s1, size_t size)
{
void *s2=NULL;

if (size!=0||s1==N ULL)
s2 = malloc(size);
else
free(s1);
if (s1!=NULL)
memcpy(s2, s1, size);
return(s2);
}


Hmm, there seems to be something wrong with this my_realloc():

new_pointer = my_realloc(NULL , 100); /* ok */
new_pointer = my_realloc(NULL , 0); /* ok */
new_pointer = my_realloc(old_ pointer, 100); /* old_pointer not free'd */
new_pointer = my_realloc(old_ pointer, 0); /* memcpy(NULL, ????, 0); */

In the last example, will the call to memcpy() invoke UB? Or, because
size is 0 (zero), it doesn't matter what the pointers point to?

--
If you're posting through Google read <http://cfaj.freeshell. org/google>
Apr 12 '06 #15

In article <sl************ *******@ID-203069.user.ind ividual.net>, Pedro Graca <he****@dodgeit .com> writes:
Michael Wojcik wrote:
The result of realloc should always be stored in a temporary
variable and should be checked for null. If it is null, remember
to free the old value:

char *newkey;
newkey = realloc(key, p);
if (! newkey)
{
free(key);
[perform error handling]
}
key = newkey;


Uh? Doesn't realloc(), when it doesn't fail, call free() all by itself
if there's a need for that? Also suppose the reallocated memory doesn't
'move' (newkey == key); doing a "free(key); " now could be disastrous.


The code above only frees key if realloc failed.

--
Michael Wojcik mi************@ microfocus.com
Apr 12 '06 #16

"Pedro Graca" <he****@dodgeit .com> wrote in message
news:sl******** ***********@ID-203069.user.ind ividual.net...
Rod Pemberton wrote:
"Chris Torek" <no****@torek.n et> wrote in message
news:e1******** @news2.newsguy. com...
(Seriously: C89 specifically said that realloc(NULL,n) was equivalent
to malloc(n), and malloc(0) *could* be equivalent to malloc(1); it
then also said that realloc(p,0) was equivalent to free(p); so what
then is realloc(NULL,0) -- is it like malloc(0) and hence like
malloc(1), or is it just free(NULL)?)
If your question wasn't rhetorical, this realloc probably answers your
question. It has undefined behavior since it doesn't determine the 'magic mystery size' of s1...

void *my_realloc (void *s1, size_t size)
{
void *s2=NULL;

if (size!=0||s1==N ULL)
s2 = malloc(size);
else
free(s1);
if (s1!=NULL)
memcpy(s2, s1, size);
return(s2);
}


Hmm, there seems to be something wrong with this my_realloc():

new_pointer = my_realloc(NULL , 100); /* ok */
new_pointer = my_realloc(NULL , 0); /* ok */
new_pointer = my_realloc(old_ pointer, 100); /* old_pointer not free'd */


That's a simple fix:
if (s1!=NULL)
{
memcpy(s2, s1, size);
free(s1);
}
new_pointer = my_realloc(old_ pointer, 0); /* memcpy(NULL, ????, 0); */
You've got that wrong. The last case is memcpy(new_poin ter,old_pointer ,0);
i.e., new_pointer = my_realloc(old_ pointer, 0); /*
memcpy(new_poin ter,old_pointer ,0); */

If size is zero, s1 is freed (which doesn't set s1 to NULL) and s2 is
returned which is NULL.
In the last example, will the call to memcpy() invoke UB? Or, because
size is 0 (zero), it doesn't matter what the pointers point to?
As I said, you've got the last one wrong. No NULL is ever passed to
memcpy(), but a size zero is. To eliminate the size zero problem, you need
to know the old size, and check that it isn't zero. Which as Chris Torek's
example shows, it's based on compiler secrets.

The point of my reply was that Chris Torek's solution will pass NULL's for
'old' that _could_ "invoke" (I really don't like "invoke," it implies a
guaranted action...) UB for the first two situations:
new_pointer = my_realloc(NULL , 100); /* not Ok for ChrisT example*/
new_pointer = my_realloc(NULL , 0); /* not Ok for ChrisT example*/


(If you're keeping score, Chris has two UB, one size zero problem. And,
mine had one coding error, and one size zero problem.)

A closer corrected realloc, would be some merger of mine and Chris', with
zero correction for size:

void *realloc (void *s1, size_t size)
{
void *s2=NULL;
size_t oldsize = __some_sort_of_ magic_done_here (old);

if (size!=0||s1==N ULL)
s2 = malloc(size);
else
free(s1);
if (s1!=NULL)
{
size=oldsize<si ze?oldsize:news ize;
if(size==0)
size=1;
memcpy(s2, s1, size);
free(s1);
}
return(s2);
}
HTH,

Rod Pemberton


Apr 12 '06 #17

"Rod Pemberton" <do*********@so rry.bitbuck.cmm > wrote in message
news:e1******** **@localhost.lo caldomain...

"Pedro Graca" <he****@dodgeit .com> wrote in message
news:sl******** ***********@ID-203069.user.ind ividual.net...
Rod Pemberton wrote:
"Chris Torek" <no****@torek.n et> wrote in message
news:e1******** @news2.newsguy. com...
> (Seriously: C89 specifically said that realloc(NULL,n) was equivalent
> to malloc(n), and malloc(0) *could* be equivalent to malloc(1); it
> then also said that realloc(p,0) was equivalent to free(p); so what
> then is realloc(NULL,0) -- is it like malloc(0) and hence like
> malloc(1), or is it just free(NULL)?)

If your question wasn't rhetorical, this realloc probably answers your
question. It has undefined behavior since it doesn't determine the 'magic mystery size' of s1...

void *my_realloc (void *s1, size_t size)
{
void *s2=NULL;

if (size!=0||s1==N ULL)
s2 = malloc(size);
else
free(s1);
if (s1!=NULL)
memcpy(s2, s1, size);
return(s2);
}
Hmm, there seems to be something wrong with this my_realloc():

new_pointer = my_realloc(NULL , 100); /* ok */
new_pointer = my_realloc(NULL , 0); /* ok */
new_pointer = my_realloc(old_ pointer, 100); /* old_pointer not free'd */


That's a simple fix:
if (s1!=NULL)
{
memcpy(s2, s1, size);
free(s1);
}
new_pointer = my_realloc(old_ pointer, 0); /* memcpy(NULL, ????, 0); */


You've got that wrong. The last case is

memcpy(new_poin ter,old_pointer ,0); i.e., new_pointer = my_realloc(old_ pointer, 0); /*
memcpy(new_poin ter,old_pointer ,0); */

If size is zero, s1 is freed (which doesn't set s1 to NULL) and s2 is
returned which is NULL.
In the last example, will the call to memcpy() invoke UB? Or, because
size is 0 (zero), it doesn't matter what the pointers point to?
As I said, you've got the last one wrong. No NULL is ever passed to
memcpy(), but a size zero is. To eliminate the size zero problem, you

need to know the old size, and check that it isn't zero. Which as Chris Torek's example shows, it's based on compiler secrets.

The point of my reply was that Chris Torek's solution will pass NULL's for
'old' that _could_ "invoke" (I really don't like "invoke," it implies a
guaranted action...) UB for the first two situations:
new_pointer = my_realloc(NULL , 100); /* not Ok for ChrisT example*/ new_pointer = my_realloc(NULL , 0); /* not Ok for ChrisT
example*/
(If you're keeping score, Chris has two UB, one size zero problem. And,
mine had one coding error, and one size zero problem.)

A closer corrected realloc, would be some merger of mine and Chris', with
zero correction for size:

void *realloc (void *s1, size_t size)
{
void *s2=NULL;
size_t oldsize = __some_sort_of_ magic_done_here (old);

if (size!=0||s1==N ULL)
s2 = malloc(size);
else
free(s1);
if (s1!=NULL)
{
size=oldsize<si ze?oldsize:news ize;
Correction:
size=oldsize<si ze?oldsize:size ;
if(size==0)
size=1;
memcpy(s2, s1, size);
free(s1);
}
return(s2);
}
HTH,

Rod Pemberton

Apr 12 '06 #18
Michael Wojcik wrote:

In article <sl************ *******@ID-203069.user.ind ividual.net>, Pedro Graca <he****@dodgeit .com> writes:
Michael Wojcik wrote:
> The result of realloc should always be stored in a temporary
> variable and should be checked for null. If it is null, remember
> to free the old value:
>
> char *newkey;
> newkey = realloc(key, p);
> if (! newkey)
> {
> free(key);
> [perform error handling]
> }
> key = newkey;


Uh? Doesn't realloc(), when it doesn't fail, call free() all by itself
if there's a need for that? Also suppose the reallocated memory doesn't
'move' (newkey == key); doing a "free(key); " now could be disastrous.


The code above only frees key if realloc failed.


I think I finally understand why I saw something wrong in that code.

If the reallocation fails and NULL is assigned to newkey, it's supposed
that the "[perform error handling]" doesn't return, so the code will
never get to the "key = newkey;" statement.
I was imagining that the code would go on, and didn't understand the
need to "free(key); " and lose all references to its memory.

--
If you're posting through Google read <http://cfaj.freeshell. org/google>
Apr 12 '06 #19
Rod Pemberton wrote:
"Pedro Graca" <he****@dodgeit .com> wrote in message
news:sl******** ***********@ID-203069.user.ind ividual.net...
Rod Pemberton wrote:
> void *my_realloc (void *s1, size_t size)
> {
> void *s2=NULL;
>
> if (size!=0||s1==N ULL)
> s2 = malloc(size);
> else
> free(s1);
> if (s1!=NULL)
> memcpy(s2, s1, size); free(s1); > return(s2);
> }
Hmm, there seems to be something wrong with this my_realloc():

new_pointer = my_realloc(NULL , 100); /* ok */
new_pointer = my_realloc(NULL , 0); /* ok */
new_pointer = my_realloc(old_ pointer, 100); /* old_pointer not free'd */


That's a simple fix:

[fix incorporated in the code above, check '>' marks]
new_pointer = my_realloc(old_ pointer, 0); /* memcpy(NULL, ????, 0); */


You've got that wrong. The last case is memcpy(new_poin ter,old_pointer ,0);
i.e., new_pointer = my_realloc(old_ pointer, 0); /*
memcpy(new_poin ter,old_pointer ,0); */

If size is zero, s1 is freed (which doesn't set s1 to NULL) and s2 is
returned which is NULL.


Right. Let's run "my_realloc(val id_old_pointer, 0);" step by step ...

void *my_realloc (void *s1, size_t size)
{
void *s2=NULL;
/* s1 --> valid_old_point er
* s2 --> NULL
* size --> 0 */

if (size!=0||s1==N ULL)
s2 = malloc(size);
else
free(s1);
/* s1 --> free'd valid_old_point er
* s2 --> NULL
* size --> 0 */

if (s1!=NULL)
memcpy(s2, s1, size);
/* And here we go ...
* s2 is NULL, s1 is the free'd valid_old_point er, size is 0
* so
*
* ...
*
* memcpy(NULL, ????, 0); */

return(s2);
}
In the last example, will the call to memcpy() invoke UB? Or, because
size is 0 (zero), it doesn't matter what the pointers point to?


As I said, you've got the last one wrong. No NULL is ever passed to
memcpy(), but a size zero is.


Where did I go wrong in my step-by-step run of my_realloc()?
To eliminate the size zero problem, you need
to know the old size, and check that it isn't zero. Which as Chris Torek's
example shows, it's based on compiler secrets.


Yes, I understand this is nothing more than an exercise in second
guessing the compiler secrets ... but I feel it's a good exercise to aid
in developing my knowledge of C.

--
If you're posting through Google read <http://cfaj.freeshell. org/google>
Apr 12 '06 #20

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

36
2843
by: Roy | last post by:
Hi all : My code below : #include <stdio.h> #include <string.h> #include <stdlib.h> char *cat(char *s, const char *t) { char *tmp;
9
307
by: James S. Singleton | last post by:
If we do q = realloc(p, 128) ; and on (successful) return of realloc, q != p, must the block pointed to by p be explicitly freed, or has realloc freed it already?
10
1527
by: James S. Singleton | last post by:
Thanks everybody for your replies. I gather that: a) How to obtain the size of the memory region pointed to by ptr in realloc(ptr, size) is implementation-dependent. b) Implementing realloc(ptr, size) using malloc(), memcpy() and free() alone, without knowing the size of the memory region pointed to by ptr, is just not possible.
4
4024
by: alex323 | last post by:
Hey. I must have an array that can be resized dynamically. I have coded an implementation of it using malloc/realloc, but I am getting a runtime error as seen below in GDB: *** glibc detected *** realloc(): invalid next size: 0x08054828 *** Program received signal SIGABRT, Aborted. 0xffffe410 in __kernel_vsyscall () (gdb) bt
28
3887
by: bwaichu | last post by:
Is it generally better to set-up a buffer (fixed sized array) and read and write to that buffer even if it is larger than what is being written to it? Or is it better to allocate memory and realloc it for the size of the what is being written each time? In other words, what is the decision factor between deciding to use a fixed size buffer or allocating memory space and reallocing the size? I don't think the code below is optimal...
2
525
by: solanki.chandrakant | last post by:
hi i have fedora linux 4 and i have simple realloc program which i am included here... plz help me to overcome the realloc to pointer to character variable. The program working 2 times but more than 2 times it gives error : realloc() - invalid next size. #include <stdio.h> #include <stdlib.h>
64
8397
by: Robert Seacord | last post by:
The C standard doesn't say anything about what happens when you call realloc with a size argument of 0. Both glibc and openbsd appear to return a valid pointer to a zero-sized object.. e.g. the return of a malloc(0). Does anyone know of a runtime where realloc() free'ed the object and then returned NULL? If so, it would make the following idiom for realloc() exploitable. Here's the idiom, snagged from an openbsd man page: if ((p2 =...
29
7890
by: marvinla | last post by:
Hello! I'm a beginner in C, and I'm having trouble with a pointer-to-pointer reallocation. This piece of code works well, but Valkyrie warns some parts (pointed below), and is breaking my real code. #include <stdio.h> #include <stdlib.h>
7
1855
by: lancer6238 | last post by:
Hi, I'm writing a program that separates a set of integers into groups and then quicksort each group individually. However, I'm having problems with my realloc() function. (Pardon me if the indentation is weird. There's no preview button here and I can't tell if my indentation is correct.) #include <stdio.h> #include <stdlib.h>
0
9902
marktang
by: marktang | last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However, people are often confused as to whether an ONU can Work As a Router. In this blog post, we’ll explore What is ONU, What Is Router, ONU & Router’s main usage, and What is the difference between ONU and Router. Let’s take a closer look ! Part I. Meaning of...
0
9752
by: Hystou | last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can effortlessly switch the default language on Windows 10 without reinstalling. I'll walk you through it. First, let's disable language synchronization. With a Microsoft account, language settings sync across devices. To prevent any complications,...
0
11037
Oralloy
by: Oralloy | last post by:
Hello folks, I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>". The problem is that using the GNU compilers, it seems that the internal comparison operator "<=>" tries to promote arguments from unsigned to signed. This is as boiled down as I can make it. Here is my compilation command: g++-12 -std=c++20 -Wnarrowing bit_field.cpp Here is the code in...
1
10764
by: Hystou | last post by:
Overview: Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows Update option using the Control Panel or Settings app; it automatically checks for updates and installs any it finds, whether you like it or not. For most users, this new feature is actually very convenient. If you want to control the update process,...
0
10371
tracyyun
by: tracyyun | last post by:
Dear forum friends, With the development of smart home technology, a variety of wireless communication protocols have appeared on the market, such as Zigbee, Z-Wave, Wi-Fi, Bluetooth, etc. Each protocol has its own unique characteristics and advantages, but as a user who is planning to build a smart home system, I am a bit confused by the choice of these technologies. I'm particularly interested in Zigbee because I've heard it does some...
1
7920
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome a new presenter, Adolph Dupré who will be discussing some powerful techniques for using class modules. He will explain when you may want to use classes instead of User Defined Types (UDT). For example, to manage the data in unbound forms. Adolph will...
0
5753
by: TSSRALBI | last post by:
Hello I'm a network technician in training and I need your help. I am currently learning how to create and manage the different types of VPNs and I have a question about LAN-to-LAN VPNs. The last exercise I practiced was to create a LAN-to-LAN VPN between two Pfsense firewalls, by using IPSEC protocols. I succeeded, with both firewalls in the same network. But I'm wondering if it's possible to do the same thing, with 2 Pfsense firewalls...
0
5945
by: adsilva | last post by:
A Windows Forms form does not have the event Unload, like VB6. What one acts like?
2
4165
muto222
by: muto222 | last post by:
How can i add a mobile payment intergratation into php mysql website.

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.