int BCEChangeEncryptionProduct(byte *sys_params_path, int *adds, int n_adds, int *rems, int n_rems)
{
global_broadcast_params_t gbs;
broadcast_system_t sys;
if (sys_params_path == NULL)
return 1;
if (adds == NULL && rems == NULL)
return 2;
LoadParams((char *) sys_params_path, &gbs, &sys);
if (n_adds > gbs->num_users)
return 3;
if (n_rems > gbs->num_users)
return 5;
Change_encr_prod_indicies(gbs, sys, adds, n_adds, rems, n_rems);
StoreParams((char *) sys_params_path, gbs, sys);
FreeBCS(sys);
pbc_free(sys);
FreeGBP(gbs);
pbc_free(gbs);
return 0;
}
LRESULT CThumbEditor::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
TRC(IDCANCEL, "Отмена");
TRC(IDOK, "OK");
TRC(IDC_THUMBSTROKECOLOR, "Цвет каймы:");
TRC(IDC_COLORSGROUP, "Цвета");
TRC(IDC_FRAMECOLORLABEL, "Цвет рамки:");
TRC(IDC_GRADIENTCOLOR1LABEL, "Цвет градиента 1:");
TRC(IDC_GRADIENTCOLOR2LABEL, "Цвет градиента 2:");
TRC(IDC_DRAWFRAME, "Обводить в рамку");
TRC(IDC_FRAMEWIDTHLABEL, "Толщина:");
TRC(IDC_THUMBPARAMS, "Параметры текста:");
TRC(IDC_THUMBTEXTCOLORLABEL, "Цвет текста:");
TRC(IDC_THUMBSTROKECOLORLABEL, "Цвет обводки:");
TRC(IDC_THUMBTEXTLABEL, "Текст:");
TRC(IDC_THUMBFONT, "Шрифт...");
TRC(IDC_ADDFILESIZE, "Выводить текст");
SetWindowText(TR("Редактирование шаблона миниатюры"));
FrameColor.SubclassWindow(GetDlgItem(IDC_FRAMECOLOR));
Color1.SubclassWindow(GetDlgItem(IDC_COLOR1));
Color2.SubclassWindow(GetDlgItem(IDC_COLOR2));
StrokeColor.SubclassWindow(GetDlgItem(IDC_THUMBTEXTCOLOR2));
ThumbTextColor.SubclassWindow(GetDlgItem(IDC_THUMBTEXTCOLOR));
CenterWindow(GetParent());
LoadParams();
ShowTextCheckboxChanged();
DrawFrameCheckboxChanged();
return 0; // Let the system set the focus
}
CClientApp::CClientApp(const char* appname, bool bThread)
{
ZION_ASSERT(!__global_client_app);
__global_client_app = this;
m_bThread = bThread;
m_bEnableTick = true;
A_MUTEX_INIT(&m_mtxQueue);
m_nRecvSize = 20*1024;
m_nSendSize = 1*1024;
LoadParams();
}
int BCEEncrypt(byte *sys_params_path, byte *CT_C0_out, byte *CT_C1_out, byte *symmetric_key_out)
{
global_broadcast_params_t gbs;
broadcast_system_t sys;
ct_t shared_CT;
element_t symmetric_key;
int retlen;
if (sys_params_path == NULL)
return 1;
if (CT_C0_out == NULL)
return 2;
if (CT_C1_out == NULL)
return 3;
if (symmetric_key_out == NULL)
return 4;
LoadParams((char *) sys_params_path, &gbs, &sys);
shared_CT = (ct_t) pbc_malloc(sizeof(struct ciphertext_s));
BroadcastKEM_using_product(gbs, sys, shared_CT, symmetric_key);
retlen = element_to_bytes(CT_C0_out, shared_CT->C0);
if (retlen != CT_C0_LENGTH)
return 5;
retlen = element_to_bytes(CT_C1_out, shared_CT->C1);
if (retlen != CT_C1_LENGTH)
return 6;
retlen = element_to_bytes(symmetric_key_out, symmetric_key);
if (retlen != SYMMETRIC_KEY_LENGTH)
return 7;
element_random(symmetric_key);
element_clear(symmetric_key);
FreeCT(shared_CT);
pbc_free(shared_CT);
FreeBCS(sys);
pbc_free(sys);
FreeGBP(gbs);
pbc_free(gbs);
return 0;
}
NS_IMETHODIMP
nsXPInstallManager::ConfirmInstall(nsIDOMWindow *aParent, const PRUnichar **aPackageList, PRUint32 aCount, PRBool *aRetval)
{
*aRetval = PR_FALSE;
nsCOMPtr<nsIDOMWindowInternal> parentWindow( do_QueryInterface(aParent) );
nsCOMPtr<nsIDialogParamBlock> params;
nsresult rv = LoadParams( aCount, aPackageList, getter_AddRefs(params) );
if ( NS_SUCCEEDED(rv) && parentWindow && params)
{
nsCOMPtr<nsIDOMWindow> newWindow;
nsCOMPtr<nsISupportsInterfacePointer> ifptr =
do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
ifptr->SetData(params);
ifptr->SetDataIID(&NS_GET_IID(nsIDialogParamBlock));
char* confirmDialogURL;
nsCOMPtr<nsIPrefBranch> pref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
if (!pref)
return rv;
rv = pref->GetCharPref(PREF_XPINSTALL_CONFIRM_DLG, &confirmDialogURL);
NS_ASSERTION(NS_SUCCEEDED(rv), "Can't invoke XPInstall FE without a FE URL! Set xpinstall.dialog.confirm");
if (NS_FAILED(rv))
return rv;
rv = parentWindow->OpenDialog(NS_ConvertASCIItoUTF16(confirmDialogURL),
NS_LITERAL_STRING("_blank"),
NS_LITERAL_STRING("chrome,centerscreen,modal,titlebar"),
ifptr,
getter_AddRefs(newWindow));
if (NS_SUCCEEDED(rv))
{
//Now get which button was pressed from the ParamBlock
PRInt32 buttonPressed = 0;
params->GetInt( 0, &buttonPressed );
*aRetval = buttonPressed ? PR_FALSE : PR_TRUE;
}
}
return rv;
}
// Initialize emitter.
void COGEmitterScrollingRay::Init(IOGGroupNode* _pNode)
{
LoadParams(_pNode);
m_pTexture = GetResourceMgr()->GetTexture(OG_RESPOOL_GAME, m_Texture);
m_Blend = OG_BLEND_ALPHAONE;
m_pVBO = m_pRenderer->CreateDynVertexBuffer(2*60);
m_bPositionUpdated = false;
m_bPosReady = false;
m_Frames.reserve(m_MappingFinishId - m_MappingStartId + 1);
for (unsigned int i = m_MappingStartId; i <= m_MappingFinishId; ++i)
{
m_Frames.push_back(m_pTexture->GetMapping(i));
}
}
RegFrame::RegFrame( wxMDIParentFrame *parent, const wxString& title )
: ChildFrame(parent, title)
{
m_panel = new wxPanel(this);
m_sizerFrame = new wxBoxSizer(wxVERTICAL);
m_textCtrlBasic = new RegRichTextCtrl(m_panel);
m_bookCtrl = new wxAuiNotebook(m_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxAUI_NB_BOTTOM);
//m_bookCtrl = new wxNotebook(m_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNB_BOTTOM);
{
wxWindow *page = MakePageDR();
m_bookCtrl->AddPage(page, wxT("DR"), false);
}
{
wxWindow *page = MakePageFPU();
m_bookCtrl->AddPage(page, wxT("FPU"), false);
}
{
wxWindow *page = MakePageMMX();
m_bookCtrl->AddPage(page, wxT("MMX"), false);
}
{
wxWindow *page = MakePage3dnow();
m_bookCtrl->AddPage(page, wxT("3DNow!"), false);
}
//m_sizerFrame->Insert(0, m_bookCtrl, wxSizerFlags(5).Expand().Border());
m_sizerFrame->Add(m_textCtrlBasic, 2, wxEXPAND);
m_sizerFrame->Add(m_bookCtrl, 1, wxEXPAND);
m_sizerFrame->Layout();
m_panel->SetSizer(m_sizerFrame);
LoadParams();
}
// Selection was made from the Select menu button of a predefined CRC settings
void CGeneralCRC::OnSelect()
{
int id = select_menu_.m_nMenuResult; // slected menu ID (= index into settings_)
if (id > 0 && id < settings_.size())
{
// Get the param string associated with the select menu item and load it into member vars
LoadParams(settings_[id]);
// Update dlg controls from members variables
UpdateData(FALSE);
// Get the menu item text and load it into the name field
CMenu menu;
menu.Attach(select_menu_.m_hMenu);
CString ss = get_menu_text(&menu, id);
menu.Detach();
SetDlgItemText(IDC_CRC_NAME, ss);
// Enable the Delete button if this is a user defined setting
GetDlgItem(IDC_CRC_DELETE)->EnableWindow(id >= last_predefined_);
last_selected_ = id;
}
}
void board_init(void)
{
GPIO_InitTypeDef gpio;
SystemCoreClockUpdate( );
// turn on peripherals needed by all
RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB |
RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD |
RCC_AHB1Periph_DMA1 | RCC_AHB1Periph_DMA2 |
RCC_AHB1Periph_BKPSRAM, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 | RCC_APB2Periph_TIM1 | RCC_APB2Periph_SYSCFG, ENABLE);
RCC_APB1PeriphClockCmd( RCC_APB1Periph_SPI2 | RCC_APB1Periph_SPI3 | RCC_APB1Periph_TIM2 |
RCC_APB1Periph_TIM3 | RCC_APB1Periph_TIM4 | RCC_APB1Periph_TIM5 | RCC_APB1Periph_TIM12 |
RCC_APB1Periph_PWR, ENABLE);
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
RCC_LSEConfig(RCC_LSE_OFF);
LEDInit(LED_BLUE);
LEDInit(LED_GREEN);
gpio.GPIO_Pin = GPIO_Pin_0;
gpio.GPIO_Mode = GPIO_Mode_OUT;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_PuPd = GPIO_PuPd_UP;
gpio.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &gpio);
GPIO_SetBits(GPIOC, GPIO_Pin_0);
gpio.GPIO_Pin = GPIO_Pin_1;
gpio.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOC, &gpio);
GPIO_ResetBits(GPIOC, GPIO_Pin_1);
//SPI1 output to electronic switch to control mask
GPIO_StructInit(&gpio);
gpio.GPIO_Pin = GPIO_Pin_6; // SPI1 MISO
gpio.GPIO_Mode = GPIO_Mode_AF;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &gpio);
GPIO_ResetBits(GPIOA, GPIO_Pin_6);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SPI3);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_SPI3);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SPI3);
// max7456 SPI MOIS MISO SLK pin config
gpio.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
gpio.GPIO_Mode = GPIO_Mode_AF;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
gpio.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOC, &gpio);
// max7456 SPI CS Pin
gpio.GPIO_Pin = GPIO_Pin_15;
gpio.GPIO_Mode = GPIO_Mode_OUT;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &gpio);
GPIO_SetBits(GPIOA,GPIO_Pin_15);
Build_Sin_Cos_Tables();
LoadParams();
checkDefaultParam();
SPI_MAX7456_init();
atti_mp_scale = (float)eeprom_buffer.params.Atti_mp_scale_real + (float)eeprom_buffer.params.Atti_mp_scale_frac * 0.01;
atti_3d_scale = (float)eeprom_buffer.params.Atti_3D_scale_real + (float)eeprom_buffer.params.Atti_3D_scale_frac * 0.01;
atti_3d_min_clipX = eeprom_buffer.params.Atti_mp_posX - (uint32_t)(22*atti_mp_scale);
atti_3d_max_clipX = eeprom_buffer.params.Atti_mp_posX + (uint32_t)(22*atti_mp_scale);
atti_3d_min_clipY = eeprom_buffer.params.Atti_mp_posY - (uint32_t)(30*atti_mp_scale);
atti_3d_max_clipY = eeprom_buffer.params.Atti_mp_posY + (uint32_t)(34*atti_mp_scale);
}
NS_IMETHODIMP
nsXPInstallManager::OpenProgressDialog(const PRUnichar **aPackageList, PRUint32 aCount, nsIObserver *aObserver)
{
// --- convert parameters into nsISupportArray members
nsCOMPtr<nsIDialogParamBlock> list;
nsresult rv = LoadParams( aCount, aPackageList, getter_AddRefs(list) );
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsISupportsInterfacePointer> listwrap(do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID));
if (listwrap) {
listwrap->SetData(list);
listwrap->SetDataIID(&NS_GET_IID(nsIDialogParamBlock));
}
nsCOMPtr<nsISupportsInterfacePointer> callbackwrap(do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID));
if (callbackwrap) {
callbackwrap->SetData(aObserver);
callbackwrap->SetDataIID(&NS_GET_IID(nsIObserver));
}
nsCOMPtr<nsISupportsArray> params(do_CreateInstance(NS_SUPPORTSARRAY_CONTRACTID));
if ( !params || !listwrap || !callbackwrap )
return NS_ERROR_FAILURE;
params->AppendElement(listwrap);
params->AppendElement(callbackwrap);
// --- open the window
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv));
if (!wwatch)
return rv;
char *statusDialogURL, *statusDialogType;
nsCOMPtr<nsIPrefBranch> pref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
if (!pref)
return rv;
const char* statusDlg = mChromeType == CHROME_SKIN ? PREF_XPINSTALL_STATUS_DLG_SKIN
: PREF_XPINSTALL_STATUS_DLG_CHROME;
rv = pref->GetCharPref(statusDlg, &statusDialogURL);
NS_ASSERTION(NS_SUCCEEDED(rv), "Can't invoke XPInstall FE without a FE URL! Set xpinstall.dialog.status");
if (NS_FAILED(rv))
return rv;
const char* statusType = mChromeType == CHROME_SKIN ? PREF_XPINSTALL_STATUS_DLG_TYPE_SKIN
: PREF_XPINSTALL_STATUS_DLG_TYPE_CHROME;
rv = pref->GetCharPref(statusType, &statusDialogType);
nsAutoString type;
type.AssignWithConversion(statusDialogType);
if (NS_SUCCEEDED(rv) && !type.IsEmpty()) {
nsCOMPtr<nsIWindowMediator> wm = do_GetService(NS_WINDOWMEDIATOR_CONTRACTID);
nsCOMPtr<nsIDOMWindowInternal> recentWindow;
wm->GetMostRecentWindow(type.get(), getter_AddRefs(recentWindow));
if (recentWindow) {
nsCOMPtr<nsIObserverService> os(do_GetService("@mozilla.org/observer-service;1"));
os->NotifyObservers(params, "xpinstall-download-started", nsnull);
recentWindow->Focus();
return NS_OK;
}
}
nsCOMPtr<nsIDOMWindow> newWindow;
rv = wwatch->OpenWindow(0,
statusDialogURL,
"_blank",
"chrome,centerscreen,titlebar,dialog=no,resizable",
params,
getter_AddRefs(newWindow));
return rv;
}
void board_init(void) {
GPIO_InitTypeDef gpio;
SystemCoreClockUpdate();
// turn on peripherals needed by all
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB |
RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD |
RCC_AHB1Periph_DMA1 | RCC_AHB1Periph_DMA2 |
RCC_AHB1Periph_BKPSRAM, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1 | RCC_APB2Periph_TIM1 | RCC_APB2Periph_SYSCFG, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2 | RCC_APB1Periph_SPI3 | RCC_APB1Periph_TIM2 |
RCC_APB1Periph_TIM3 | RCC_APB1Periph_TIM4 | RCC_APB1Periph_TIM5 | RCC_APB1Periph_TIM12 |
RCC_APB1Periph_PWR, ENABLE);
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
RCC_LSEConfig(RCC_LSE_OFF);
LEDInit(LED_BLUE);
LEDInit(LED_GREEN);
gpio.GPIO_Pin = GPIO_Pin_0;
gpio.GPIO_Mode = GPIO_Mode_OUT;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_PuPd = GPIO_PuPd_UP;
gpio.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_Init(GPIOC, &gpio);
GPIO_SetBits(GPIOC, GPIO_Pin_0);
gpio.GPIO_Pin = GPIO_Pin_1;
gpio.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOC, &gpio);
GPIO_ResetBits(GPIOC, GPIO_Pin_1);
//SPI1 output to electronic switch to control mask
GPIO_StructInit(&gpio);
gpio.GPIO_Pin = GPIO_Pin_6; // SPI1 MISO
gpio.GPIO_Mode = GPIO_Mode_AF;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &gpio);
GPIO_ResetBits(GPIOA, GPIO_Pin_6);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SPI3);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_SPI3);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SPI3);
// max7456 SPI MOIS MISO SLK pin config
gpio.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
gpio.GPIO_Mode = GPIO_Mode_AF;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
gpio.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOC, &gpio);
// max7456 SPI CS Pin
gpio.GPIO_Pin = GPIO_Pin_15;
gpio.GPIO_Mode = GPIO_Mode_OUT;
gpio.GPIO_OType = GPIO_OType_PP;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
gpio.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &gpio);
GPIO_SetBits(GPIOA, GPIO_Pin_15);
Build_Sin_Cos_Tables();
bool force_clear_params = false;
force_clear_params = test_force_clear_all_params();
if (force_clear_params)
{
clear_all_params();
}
LoadParams();
checkDefaultParam();
SPI_MAX7456_init();
set_up_offsets_and_scale();
}
EQKAnalyzer::EQKAnalyzer( const std::string fparam, bool MoveF ) {
LoadParams( fparam, MoveF );
CheckParams();
}
//----------------------------------------
void CBratProcessExportAscii::GetParameters()
{
LoadParams(m_commandFileName);
CheckFileParams();
CFileParams& params = *m_fileParams;
CUnit unit;
// Verify keyword occurences
uint32_t nbExpr = params.CheckCount(kwFIELD, 1, -1);
uint32_t nbFormats = params.CheckCount(kwFIELD_FORMAT, 0, -1);
uint32_t nbNames = params.CheckCount(kwFIELD_NAME, 0, -1);
uint32_t nbOutput = params.CheckCount(kwOUTPUT, 0);
params.CheckCount(kwRECORD);
params.CheckCount(kwFIELD_UNIT, nbExpr);
if (nbFormats != 0)
{
params.CheckCount(kwFIELD_FORMAT, nbExpr);
}
if (nbNames != 0)
{
params.CheckCount(kwFIELD_NAME, nbExpr);
}
// Get keyword values
CTrace *p = CTrace::GetInstance();
if (nbOutput != 0)
{
params.m_mapParam[kwOUTPUT]->GetValue(m_outputFileName);
}
if (m_outputFileName != "")
{
ofstream *oFile;
p->Tracer(1, CBratProcess::PCT_StrFmt, "Output file", m_outputFileName.c_str());
oFile = new ofstream;
oFile->open(m_outputFileName.c_str());
if (oFile->fail())
{
throw CFileException("Error creating file", m_outputFileName, BRATHL_IO_ERROR);
}
m_outputFile = oFile;
}
else
{
p->Tracer(1, CBratProcess::PCT_StrFmt, "Output file", "Standard output");
m_outputFile = &cout;
}
params.m_mapParam[kwRECORD]->GetValue(m_recordName);
p->Tracer(1, CBratProcess::PCT_StrFmt, "Data set name", m_recordName.c_str());
//ExpandArray = false;
if (params.CheckCount(kwEXPAND_ARRAY, 0, 1) == 1)
{
params.m_mapParam[kwEXPAND_ARRAY]->GetValue(m_expandArray);
}
p->Tracer(1, CBratProcess::PCT_IntFmt, "Expand array", m_expandArray);
if (params.CheckCount(kwDATE_AS_PERIOD, 0, 1) == 1)
{
params.m_mapParam[kwDATE_AS_PERIOD]->GetValue(m_dateAsPeriod);
}
p->Tracer(1, CBratProcess::PCT_IntFmt, "Date as period", m_dateAsPeriod);
GetSelectParameter(params);
ResizeArrayDependOnFields(nbExpr);
uint32_t index;
for (index = 0; index < nbExpr; index++)
{
string* namesTmp = NULL;
if (nbNames > 0)
{
namesTmp = &m_names[index];
}
this->GetDefinition(params,
kwFIELD,
m_fields[index],
namesTmp,
NULL,
&m_units[index],
NULL,
NULL,
&m_formats[index],
NULL,
"Value/Column",
index,
nbExpr);
}
DeleteFileParams();
}
//start_index从1开始，不算0
int BCEGenPrivateKeys(byte *sys_params_path, byte *sys_priv_key, int num_user, int start_index, int length, byte *user_priv_keys_out, int check_array)
{
global_broadcast_params_t gbs;
broadcast_system_t sys;
int priv_key_read, i;
//struct single_priv_key_s user_keys[length]; // Problematic Memory Allocation
struct single_priv_key_s *user_keys;
char *recip;
// char recip[num_user / NUM_USER_DIVISOR];
if (sys_params_path == NULL)
return 1;
if (sys_priv_key == NULL)
return 2;
if (num_user % NUM_USER_DIVISOR != 0)
return 3;
if (start_index % NUM_USER_DIVISOR != 1)
return 4;
if (user_priv_keys_out == NULL)
return 6;
if (length > check_array)
return -2;
LoadParams((char *) sys_params_path, &gbs, &sys);
priv_key_read = element_from_bytes(sys->priv_key, sys_priv_key);
if (priv_key_read != BCE_ZR_LENGTH)
return -1;
recip = (char *) malloc(num_user / NUM_USER_DIVISOR);
memset(recip, BIT_VECTOR_UNIT_VALUE, num_user / NUM_USER_DIVISOR);
user_keys = (priv_key_t) malloc(length * sizeof(struct single_priv_key_s)); //**
for (i = 0; i < length; i++)
{
Get_priv_key(gbs, sys, start_index + i, &user_keys[i]);
Gen_decr_prod_from_bitvec(gbs, start_index + i, recip, &user_keys[i]);
}
for (i = 0; i < length; i++)
{
int_to_bytes(user_keys[i].index, user_priv_keys_out);
user_priv_keys_out += 4;
user_priv_keys_out += element_to_bytes(user_priv_keys_out, user_keys[i].g_i_gamma);
user_priv_keys_out += element_to_bytes(user_priv_keys_out, user_keys[i].g_i);
user_priv_keys_out += element_to_bytes(user_priv_keys_out, user_keys[i].h_i);
user_priv_keys_out += element_to_bytes(user_priv_keys_out, user_keys[i].decr_prod);
}
memset(recip, BIT_VECTOR_CLEAR_UNIT_VALUE, num_user / NUM_USER_DIVISOR);
free(recip);
for (i = 0; i < length; i++)
{
FreePK(&user_keys[i]);
}
free(user_keys);
FreeBCS(sys);
pbc_free(sys);
FreeGBP(gbs);
pbc_free(gbs);
return 0;
}
