Attachment #160945 for bug #226867

View | Details | Raw Unified | Return to bug 226867
Collapse All | Expand All

Lines 48-53 Link Here

(-)boxbackup-0.10,bak/bin/bbackupctl/bbackupctl.cpp (+1 lines)
48	#include "Box.h"	48	#include "Box.h"
49		49
50	#include <stdio.h>	50	#include <stdio.h>
		51	#include <stdlib.h>
51		52
52	#ifdef HAVE_UNISTD_H	53	#ifdef HAVE_UNISTD_H
53	#include <unistd.h>	54	#include <unistd.h>

Lines 51-56 Link Here

(-)boxbackup-0.10,bak/bin/bbackupquery/bbackupquery.cpp (+1 lines)
51	#include <unistd.h>	51	#include <unistd.h>
52	#endif	52	#endif
53	#include <stdio.h>	53	#include <stdio.h>
		54	#include <stdlib.h>
54	#include <sys/types.h>	55	#include <sys/types.h>
55	#ifdef HAVE_LIBREADLINE	56	#ifdef HAVE_LIBREADLINE
56	#ifdef HAVE_READLINE_READLINE_H	57	#ifdef HAVE_READLINE_READLINE_H

Lines 51-56 Link Here

(-)boxbackup-0.10,bak/bin/bbstoreaccounts/bbstoreaccounts.cpp (+1 lines)
51	#include <stdio.h>	51	#include <stdio.h>
52	#include <sys/types.h>	52	#include <sys/types.h>
53	#include <limits.h>	53	#include <limits.h>
		54	#include <string.h>
54	#include <vector>	55	#include <vector>
55	#include <algorithm>	56	#include <algorithm>
56		57




	char* buffer = static_cast<char*>(outputBlock.GetBuffer());

	// Add the path name for the symbolic link, and add 0 termination
	::memcpy(buffer+oldSize, linkedTo, linkedToSize);
	buffer[oldSize+linkedToSize] = '\0';
}
#endif


				// Store length and text for attibute name
				u_int16_t keyLength = htons(attrKey.size()+1);
				::memcpy(buffer+xattrSize, &keyLength, sizeof(u_int16_t));
				xattrSize += sizeof(u_int16_t);
				::memcpy(buffer+xattrSize, attrKey.c_str(), attrKey.size()+1);
				xattrSize += attrKey.size()+1;

				// Leave space for value size


				// Fill in value size
				u_int32_t valueLength = htonl(valueSize);
				::memcpy(buffer+valueSizeOffset, &valueLength, sizeof(u_int32_t));
			}

			// Fill in attribute block size
			u_int32_t xattrBlockLength = htonl(xattrSize-xattrBlockSizeOffset-sizeof(u_int32_t));
			::memcpy(buffer+xattrBlockSizeOffset, &xattrBlockLength, sizeof(u_int32_t));

			outputBlock.ResizeBlock(xattrSize);
		}

		}
#endif

		xattrOffset += ::strlen(reinterpret_cast<char*>(pattr+1))+1;
	}
	
	// If working as root, set user IDs

	const char* buffer = static_cast<char*>(mpClearAttributes->GetBuffer());

	u_int32_t xattrBlockLength = 0;
	::memcpy(&xattrBlockLength, buffer+xattrOffset, sizeof(u_int32_t));
	int xattrBlockSize = ntohl(xattrBlockLength);
	xattrOffset += sizeof(u_int32_t);


	while(xattrOffset<xattrEnd)
	{
		u_int16_t keyLength = 0;
		::memcpy(&keyLength, buffer+xattrOffset, sizeof(u_int16_t));
		int keySize = ntohs(keyLength);
		xattrOffset += sizeof(u_int16_t);


		xattrOffset += keySize;

		u_int32_t valueLength = 0;
		::memcpy(&valueLength, buffer+xattrOffset, sizeof(u_int32_t));
		int valueSize = ntohl(valueLength);
		xattrOffset += sizeof(u_int32_t);


Lines 70-75 Link Here

(-)boxbackup-0.10,bak/lib/backupclient/BackupStoreFileDiff.cpp (+2 lines)
70		70
71	#include "MemLeakFindOn.h"	71	#include "MemLeakFindOn.h"
72		72
		73	#include <string.h>
		74
73	using namespace BackupStoreFileCryptVar;	75	using namespace BackupStoreFileCryptVar;
74	using namespace BackupStoreFileCreation;	76	using namespace BackupStoreFileCreation;
75		77

Lines 62-67 Link Here

(-)boxbackup-0.10,bak/lib/backupclient/BackupStoreFileEncodeStream.cpp (+2 lines)
62		62
63	#include "MemLeakFindOn.h"	63	#include "MemLeakFindOn.h"
64		64
		65	#include <string.h>
		66
65	using namespace BackupStoreFileCryptVar;	67	using namespace BackupStoreFileCryptVar;
66		68
67		69

Lines 53-58 Link Here

(-)boxbackup-0.10,bak/lib/backupclient/BackupStoreFile.h (+1 lines)
53	#include "BackupStoreFilename.h"	53	#include "BackupStoreFilename.h"
54		54
55	#include <memory>	55	#include <memory>
		56	#include <malloc.h>
56		57
57	typedef struct	58	typedef struct
58	{	59	{

Lines 57-62 Link Here

(-)boxbackup-0.10,bak/lib/common/Configuration.cpp (+2 lines)
57		57
58	#include "MemLeakFindOn.h"	58	#include "MemLeakFindOn.h"
59		59
		60	#include <string.h>
		61
60	// utility whitespace function	62	// utility whitespace function
61	inline bool iw(int c)	63	inline bool iw(int c)
62	{	64	{

Lines 53-58 Link Here

(-)boxbackup-0.10,bak/lib/common/WaitForEvent.cpp (+1 lines)
53		53
54	#include <errno.h>	54	#include <errno.h>
55	#include <string.h>	55	#include <string.h>
		56	#include <malloc.h>
56		57
57	#include "WaitForEvent.h"	58	#include "WaitForEvent.h"
58		59

Lines 59-64 Link Here

(-)boxbackup-0.10,bak/lib/raidfile/RaidFileRead.cpp (+1 lines)
59		59
60	#include <stdio.h>	60	#include <stdio.h>
61	#include <string.h>	61	#include <string.h>
		62	#include <malloc.h>
62	#include <memory>	63	#include <memory>
63	#include <map>	64	#include <map>
64		65

Return to bug 226867

Lines 481-487 Link Here

(-)boxbackup-0.10,bak/lib/backupclient/BackupClientFileAttributes.cpp (-9 / +9 lines)
481	char* buffer = static_cast<char*>(outputBlock.GetBuffer());	481	char* buffer = static_cast<char*>(outputBlock.GetBuffer());
482		482
483	// Add the path name for the symbolic link, and add 0 termination	483	// Add the path name for the symbolic link, and add 0 termination
484	std::memcpy(buffer+oldSize, linkedTo, linkedToSize);	484	::memcpy(buffer+oldSize, linkedTo, linkedToSize);
485	buffer[oldSize+linkedToSize] = '\0';	485	buffer[oldSize+linkedToSize] = '\0';
486	}	486	}
487	#endif	487	#endif
Lines 549-557 Link Here
549		549
550	// Store length and text for attibute name	550	// Store length and text for attibute name
551	u_int16_t keyLength = htons(attrKey.size()+1);	551	u_int16_t keyLength = htons(attrKey.size()+1);
552	std::memcpy(buffer+xattrSize, &keyLength, sizeof(u_int16_t));	552	::memcpy(buffer+xattrSize, &keyLength, sizeof(u_int16_t));
553	xattrSize += sizeof(u_int16_t);	553	xattrSize += sizeof(u_int16_t);
554	std::memcpy(buffer+xattrSize, attrKey.c_str(), attrKey.size()+1);	554	::memcpy(buffer+xattrSize, attrKey.c_str(), attrKey.size()+1);
555	xattrSize += attrKey.size()+1;	555	xattrSize += attrKey.size()+1;
556		556
557	// Leave space for value size	557	// Leave space for value size
Lines 584-595 Link Here
584		584
585	// Fill in value size	585	// Fill in value size
586	u_int32_t valueLength = htonl(valueSize);	586	u_int32_t valueLength = htonl(valueSize);
587	std::memcpy(buffer+valueSizeOffset, &valueLength, sizeof(u_int32_t));	587	::memcpy(buffer+valueSizeOffset, &valueLength, sizeof(u_int32_t));
588	}	588	}
589		589
590	// Fill in attribute block size	590	// Fill in attribute block size
591	u_int32_t xattrBlockLength = htonl(xattrSize-xattrBlockSizeOffset-sizeof(u_int32_t));	591	u_int32_t xattrBlockLength = htonl(xattrSize-xattrBlockSizeOffset-sizeof(u_int32_t));
592	std::memcpy(buffer+xattrBlockSizeOffset, &xattrBlockLength, sizeof(u_int32_t));	592	::memcpy(buffer+xattrBlockSizeOffset, &xattrBlockLength, sizeof(u_int32_t));
593		593
594	outputBlock.ResizeBlock(xattrSize);	594	outputBlock.ResizeBlock(xattrSize);
595	}	595	}
Lines 676-682 Link Here
676	}	676	}
677	#endif	677	#endif
678		678
679	xattrOffset += std::strlen(reinterpret_cast<char*>(pattr+1))+1;	679	xattrOffset += ::strlen(reinterpret_cast<char*>(pattr+1))+1;
680	}	680	}
681		681
682	// If working as root, set user IDs	682	// If working as root, set user IDs
Lines 817-823 Link Here
817	const char* buffer = static_cast<char*>(mpClearAttributes->GetBuffer());	817	const char* buffer = static_cast<char*>(mpClearAttributes->GetBuffer());
818		818
819	u_int32_t xattrBlockLength = 0;	819	u_int32_t xattrBlockLength = 0;
820	std::memcpy(&xattrBlockLength, buffer+xattrOffset, sizeof(u_int32_t));	820	::memcpy(&xattrBlockLength, buffer+xattrOffset, sizeof(u_int32_t));
821	int xattrBlockSize = ntohl(xattrBlockLength);	821	int xattrBlockSize = ntohl(xattrBlockLength);
822	xattrOffset += sizeof(u_int32_t);	822	xattrOffset += sizeof(u_int32_t);
823		823
Lines 831-837 Link Here
831	while(xattrOffset<xattrEnd)	831	while(xattrOffset<xattrEnd)
832	{	832	{
833	u_int16_t keyLength = 0;	833	u_int16_t keyLength = 0;
834	std::memcpy(&keyLength, buffer+xattrOffset, sizeof(u_int16_t));	834	::memcpy(&keyLength, buffer+xattrOffset, sizeof(u_int16_t));
835	int keySize = ntohs(keyLength);	835	int keySize = ntohs(keyLength);
836	xattrOffset += sizeof(u_int16_t);	836	xattrOffset += sizeof(u_int16_t);
837		837
Lines 839-845 Link Here
839	xattrOffset += keySize;	839	xattrOffset += keySize;
840		840
841	u_int32_t valueLength = 0;	841	u_int32_t valueLength = 0;
842	std::memcpy(&valueLength, buffer+xattrOffset, sizeof(u_int32_t));	842	::memcpy(&valueLength, buffer+xattrOffset, sizeof(u_int32_t));
843	int valueSize = ntohl(valueLength);	843	int valueSize = ntohl(valueLength);
844	xattrOffset += sizeof(u_int32_t);	844	xattrOffset += sizeof(u_int32_t);
845		845